ai function helper
1.0.0
AI Function Helper est un puissant module Node.js qui simplifie l'intégration des modèles GPT d'OpenAI dans vos applications. Il fournit un moyen structuré d'interagir avec les modèles d'IA, garantissant des réponses cohérentes et formatées.
Installez l'assistance de fonction AI à l'aide de NPM:
npm install ai-function-helperVoici un exemple simple pour vous aider à démarrer:
const { createAiFunctionInstance } = require ( 'ai-function-helper' ) ;
// Create an instance with your OpenAI API key
const aiFunction = createAiFunctionInstance ( 'your_api_key_here' ) ;
// Define your function
const options = {
functionName : 'generate_haiku' ,
model : 'gpt-3.5-turbo' ,
args : { topic : 'spring' } ,
description : 'Generate a haiku about the given topic.' ,
outputSchema : {
type : "object" ,
properties : {
haiku : { type : "string" }
} ,
required : [ "haiku" ]
}
} ;
// Call the function
aiFunction ( options )
. then ( result => console . log ( result . haiku ) )
. catch ( error => console . error ( error ) ) ; Pour utiliser AI Function Helper, vous devez d'abord créer une instance avec votre clé API OpenAI:
const { createAiFunctionInstance } = require ( 'ai-function-helper' ) ;
const aiFunction = createAiFunctionInstance ( 'your_api_key_here' ) ;Vous pouvez également utiliser une URL de point de terminaison personnalisée:
const aiFunction = createAiFunctionInstance ( 'your_api_key_here' , 'https://api.openai.com/v1' ) ;Alternativement, vous pouvez utiliser une instance OpenAI existante:
const OpenAI = require ( 'openai' ) ;
const openai = new OpenAI ( { apiKey : 'your_api_key_here' } ) ;
const aiFunction = createAiFunctionInstance ( openai ) ;Une fois que vous avez une instance, vous pouvez appeler les fonctions d'IA en fournissant des options:
const result = await aiFunction ( {
functionName : 'example_function' ,
model : 'gpt-4o' ,
args : { param1 : 'value1' , param2 : 'value2' } ,
description : 'This is an example function.' ,
outputSchema : {
type : "object" ,
properties : {
result : { type : "string" }
} ,
required : [ "result" ]
}
} ) ; L' aiFunction prend un objet Options avec les propriétés suivantes:
| Option | Taper | Description | Défaut |
|---|---|---|---|
functionName | chaîne | Nom de la fonction AI | 'custom_function' |
args | objet / chaîne | Arguments pour la fonction | - |
description | chaîne | Description du but de la fonction | - |
outputSchema | objet | Type de retour attendu (schéma JSON ou schéma ZOD) | - |
strictReturn | booléen | Appliquer une validation de type de retour strict | true |
showDebug | booléen | Imprimer les informations de débogage à la console | false |
debugLevel | nombre | Niveau d'informations de débogage (0-2) | 0 |
temperature | nombre | Température d'échantillonnage pour le modèle d'IA | 0.6 |
frequency_penalty | nombre | Pénalité de fréquence pour le modèle d'IA | 0 |
presence_penalty | nombre | Pénalité de présence pour le modèle d'IA | 0 |
model | chaîne | Modèle d'IA à utiliser | 'gpt-4o-mini' |
max_tokens | nombre | Nombre maximum de jetons à générer | 1000 |
top_p | nombre | Valeur P supérieure pour le modèle AI | null |
blockHijack | booléen | Empêcher un détournement rapide | false |
blockHijackThrowError | booléen | Lancer une erreur sur la tentative de détournement | false |
tools | tableau | Fonctions d'assistance à utiliser dans la fonction principale | [] |
stream | booléen | Activer le streaming de réponse | false |
streamCallback | fonction | Rappel pour les réponses en streaming | null |
promptVars | objet | Variables à utiliser dans l'invite | {} |
images | chaîne / tableau | URL d'image pour les modèles de vision | null |
imageQuality | chaîne | Qualité de l'image pour les modèles de vision | 'low' |
minifyJSON | booléen | Sortie JSON minifée | false |
history | tableau | Histoire de la conversation pour le contexte | [] |
forceJsonMode | booléen | Force le mode JSON pour les modèles non JSON | false |
timeout | nombre | Timeout pour les appels API (en millisecondes) | 120000 |
maxRetries | nombre | Nombre maximum de tentatives pour les appels API | 0 |
includeThinking | booléen | Inclure le processus de réflexion de l'IA dans la sortie de débogage | false |
SUCTIONSCHEMA : définit la structure attendue de la sortie de la fonction AI à l'aide de schéma JSON ou de schéma ZOD. Cela garantit que le modèle d'IA renvoie les données dans le format que votre application attend.
Outils : un tableau de fonctions d'assistance qui peuvent être utilisées dans la fonction AI principale. Chaque outil est un objet avec des propriétés name , function_call , description et parameters .
Blockhijack : Lorsqu'il est activé, cette fonction empêche le modèle d'IA de suivre les instructions des messages utilisateur qui tentent de remplacer le comportement prévu de la fonction.
PromptVars : vous permet de définir des variables qui seront remplacées dans la description de la fonction, offrant plus de flexibilité dans l'ingénierie rapide.
Images : permet d'utiliser des entrées d'image pour les modèles compatibles avec la vision, en élargissant les types de tâches que l'IA peut effectuer.
Comprend : lorsqu'il est défini sur true , cette option comprend le processus de réflexion de l'IA dans la sortie de débogage, fournissant un aperçu de la façon dont l'IA arrive à ses conclusions. Ceci est particulièrement utile pour les tâches complexes de résolution de problèmes et le débogage.
L'option includeThinking vous permet de capturer le processus de réflexion de l'IA avant de gérer la sortie finale. Cette fonctionnalité offre plusieurs avantages:
Amélioration de la qualité de la réponse : en «pensant» avant de répondre, l'IA peut organiser ses pensées et fournir des réponses plus cohérentes et bien structurées.
Transparence : vous pouvez voir le raisonnement derrière les réponses de l'IA, qui est utile pour déboguer et comprendre comment l'IA est arrivé à ses conclusions.
Aide de débogage : le processus de réflexion peut être inestimable lorsque des invites affinées ou un dépannage des sorties inattendues.
Lorsqu'il est activé, le processus de réflexion de l'IA est inclus dans la sortie de débogage mais n'est pas renvoyé dans le cadre du résultat final. Voici comment l'utiliser:
const options = {
functionName : 'complex_calculation' ,
args : { expression : '15*87 + ( 129/ (48*0.5) ) +12' } ,
description : 'Perform a complex mathematical calculation and show the steps.' ,
outputSchema : {
type : "object" ,
properties : {
result : { type : "number" }
} ,
required : [ "result" ]
} ,
includeThinking : true ,
showDebug : true // Set this to true to see the thinking process in the console
} ;
const result = await aiFunction ( options ) ; Dans la sortie de débogage, vous verrez le processus de réflexion enfermé dans <|start_of_thinking|> et <|end_of_thinking|> tags. Par exemple:
--- Thinking Process ---
To solve the expression '15*87 + ( 129/ (48*0.5) ) +12', I'll break it down into steps:
1. First, let's solve the parentheses:
(48*0.5) = 24
2. Now we can simplify the division:
129 / 24 = 5.375
3. Let's calculate 15*87:
15*87 = 1305
4. Now we have simplified the expression to:
1305 + 5.375 + 12
5. Let's add these numbers:
1305 + 5.375 = 1310.375
1310.375 + 12 = 1322.375
Therefore, the final result is 1322.375.
--- Parsed JSON Output ---
{
"result": 1322.375
}
Notez que le processus de réflexion n'est visible que dans la sortie de débogage et n'affecte pas la structure ou le contenu du résultat retourné. Cette fonctionnalité est particulièrement utile pour les tâches complexes où la compréhension du raisonnement de l'IA peut conduire à une meilleure ingénierie rapide et à des résultats plus précis.
Dans cet exemple, nous pouvons voir comment l'IA décompose le calcul complexe en étapes gérables, ce qui facilite la vérification du résultat et la compréhension de l'approche de résolution de problèmes. Ce niveau de détail dans le processus de réflexion peut être particulièrement précieux pour le débogage, l'éducation ou lorsque les étapes pour parvenir à une conclusion sont aussi importantes que la réponse finale elle-même.
Activer le streaming pour traiter les réponses en temps réel:
const options = {
// ... other options ...
stream : true ,
streamCallback : ( chunk ) => {
console . log ( 'Received chunk:' , chunk ) ;
}
} ; La fonction de streaming vous permet de traiter les réponses d'IA en temps réel, ce qui peut être particulièrement utile pour les tâches de longue durée ou lorsque vous souhaitez fournir des commentaires immédiats aux utilisateurs. Voici un exemple d'utilisation de l'option stream avec un streamCallback :
const { createAiFunctionInstance } = require ( 'ai-function-helper' ) ;
const aiFunction = createAiFunctionInstance ( 'your_api_key_here' ) ;
async function generateStory ( ) {
let story = '' ;
const options = {
functionName : 'generate_story' ,
model : 'gpt-4o' ,
args : {
theme : 'space exploration' ,
length : 'short'
} ,
description : 'Generate a short story about space exploration.' ,
// We don't use 'outputSchema' to return a text instead of a JSON
stream : true ,
streamCallback : ( chunk ) => {
const content = chunk . choices [ 0 ] ?. delta ?. content ;
if ( content ) {
story += content ;
console . log ( 'Received chunk:' , content ) ;
// You can update your UI here with the new content
}
}
} ;
try {
const result = await aiFunction ( options ) ;
// The result here will be the complete response
console . log ( 'Final story:' , story ) ;
return story ;
} catch ( error ) {
console . error ( 'Error generating story:' , error ) ;
}
}
generateStory ( ) ;Dans cet exemple:
stream: true dans les options pour activer le streaming.streamCallback qui reçoit des morceaux de la réponse à leur arrivée.Cette approche vous permet de gérer la réponse de l'IA en temps réel, ce qui peut être bénéfique pour:
N'oubliez pas que lors de l'utilisation du streaming, le résultat final renvoyé par aiFunction sera la réponse complète, vous pouvez donc toujours l'utiliser si nécessaire.
Définissez les fonctions d'assistance à utiliser dans votre fonction IA principale:
const options = {
// ... other options ...
tools : [
{
name : "generate_password" ,
function_call : ( { length = 5 , passwordCount = 1 } ) => {
// Password generation logic here
} ,
description : "Generate a random password" ,
parameters : {
type : "object" ,
properties : {
length : { type : "integer" } ,
passwordCount : { type : "integer" }
}
}
}
]
} ;Activer la protection contre le détournement rapide:
const options = {
// ... other options ...
blockHijack : true ,
blockHijackThrowError : true // Optional: throw error instead of returning a message
} ;Pour les modèles capables de vision, vous pouvez inclure des entrées d'image:
const options = {
// ... other options ...
images : 'https://example.com/image.jpg' ,
// Or
images : [ 'https://example.com/image1.jpg' , 'https://example.com/image2.jpg' ] ,
imageQuality : 'high'
} ;Fournir un contexte à partir des interactions précédentes:
const options = {
// ... other options ...
history : [
{ role : "user" , content : "What's the weather like?" } ,
{ role : "assistant" , content : "I'm sorry, but I don't have access to real-time weather information. Is there anything else I can help you with?" }
]
} ; Voici quelques exemples engageants qui présentent la polyvalence et la puissance du module aiFunction :
const options = {
functionName : 'generate_quiz' ,
model : 'gpt-4o' ,
args : { topic : 'space exploration' , difficulty : 'medium' , num_questions : 2 } ,
description : 'Generate a quiz with multiple-choice questions on the given topic.' ,
outputSchema : {
type : "array" ,
items : {
type : "object" ,
properties : {
question : { type : "string" } ,
options : {
type : "array" ,
items : { type : "string" } ,
minItems : 4 ,
maxItems : 4
} ,
correct_answer : { type : "string" }
} ,
required : [ "question" , "options" , "correct_answer" ]
}
}
} ;
const quiz = await aiFunction ( options ) ;
console . log ( JSON . stringify ( quiz , null , 2 ) ) ;Sortie attendue:
[
{
"question" : " Which space agency launched the first artificial satellite, Sputnik 1? " ,
"options" : [
" NASA " ,
" Soviet Union " ,
" European Space Agency " ,
" China National Space Administration "
],
"correct_answer" : " Soviet Union "
},
{
"question" : " What year did the Apollo 11 mission successfully land humans on the Moon? " ,
"options" : [
" 1967 " ,
" 1969 " ,
" 1971 " ,
" 1973 "
],
"correct_answer" : " 1969 "
}
] const { z } = require ( 'zod' ) ;
const options = {
functionName : 'create_recipe' ,
model : 'gpt-4o' ,
args : { cuisine : 'Italian' , main_ingredient : 'pasta' , dietary_restriction : 'vegetarian' } ,
description : 'Create a recipe based on the given cuisine, main ingredient, and dietary restriction.' ,
outputSchema : z . object ( {
name : z . string ( ) ,
ingredients : z . array ( z . string ( ) ) ,
instructions : z . array ( z . string ( ) ) ,
prep_time : z . string ( ) ,
cook_time : z . string ( ) ,
servings : z . number ( ) . int ( )
} )
} ;
const recipe = await aiFunction ( options ) ;
console . log ( JSON . stringify ( recipe , null , 2 ) ) ;Sortie attendue:
{
"name" : " Vegetarian Pasta Primavera " ,
"ingredients" : [
" 12 oz penne pasta " ,
" 2 cups mixed vegetables (bell peppers, zucchini, carrots) " ,
" 1/4 cup olive oil " ,
" 3 cloves garlic, minced " ,
" 1/2 cup grated Parmesan cheese " ,
" 1/4 cup fresh basil, chopped " ,
" Salt and pepper to taste "
],
"instructions" : [
" Cook pasta according to package instructions. Reserve 1/2 cup pasta water. " ,
" In a large skillet, heat olive oil over medium heat. Add minced garlic and sauté for 1 minute. " ,
" Add mixed vegetables to the skillet and cook for 5-7 minutes until tender-crisp. " ,
" Drain pasta and add it to the skillet with vegetables. Toss to combine. " ,
" Add Parmesan cheese, basil, and pasta water as needed to create a light sauce. " ,
" Season with salt and pepper to taste. Serve hot. "
],
"prep_time" : " 15 minutes " ,
"cook_time" : " 20 minutes " ,
"servings" : 4
} const options = {
functionName : 'analyze_reviews' ,
model : 'gpt-4o' ,
args : {
reviews : [
"The product exceeded my expectations. Great value for money!" ,
"Disappointed with the quality. Wouldn't recommend." ,
"Average product, nothing special but does the job."
]
} ,
description : 'Analyze the sentiment of customer reviews and categorize them.' ,
outputSchema : {
type : "array" ,
items : {
type : "object" ,
properties : {
review : { type : "string" } ,
sentiment : { type : "string" , enum : [ "positive" , "neutral" , "negative" ] } ,
score : { type : "number" , minimum : 0 , maximum : 1 }
} ,
required : [ "review" , "sentiment" , "score" ]
}
}
} ;
const sentiment_analysis = await aiFunction ( options ) ;
console . log ( JSON . stringify ( sentiment_analysis , null , 2 ) ) ;Sortie attendue:
[
{
"review" : " The product exceeded my expectations. Great value for money! " ,
"sentiment" : " positive " ,
"score" : 0.9
},
{
"review" : " Disappointed with the quality. Wouldn't recommend. " ,
"sentiment" : " negative " ,
"score" : 0.2
},
{
"review" : " Average product, nothing special but does the job. " ,
"sentiment" : " neutral " ,
"score" : 0.5
}
] const { z } = require ( 'zod' ) ;
const options = {
functionName : 'create_travel_itinerary' ,
model : 'gpt-4o' ,
args : { destination : 'Tokyo' , duration : 3 , interests : [ 'technology' , 'culture' , 'food' ] } ,
description : 'Create a daily travel itinerary for the specified destination and duration, considering the traveler's interests.' ,
outputSchema : z . object ( {
destination : z . string ( ) ,
duration : z . number ( ) . int ( ) ,
daily_plans : z . array ( z . object ( {
day : z . number ( ) . int ( ) ,
activities : z . array ( z . object ( {
time : z . string ( ) ,
activity : z . string ( ) ,
description : z . string ( )
} ) )
} ) )
} )
} ;
const itinerary = await aiFunction ( options ) ;
console . log ( JSON . stringify ( itinerary , null , 2 ) ) ;Sortie attendue:
{
"destination" : " Tokyo " ,
"duration" : 3 ,
"daily_plans" : [
{
"day" : 1 ,
"activities" : [
{
"time" : " 09:00 " ,
"activity" : " Visit Akihabara " ,
"description" : " Explore the technology and electronics district, known for its gadgets and anime culture. "
},
{
"time" : " 13:00 " ,
"activity" : " Lunch at a Robot Restaurant " ,
"description" : " Experience a unique dining experience with robot performances. "
},
{
"time" : " 15:00 " ,
"activity" : " Tour the Miraikan Science Museum " ,
"description" : " Discover cutting-edge technology and scientific innovations at this interactive museum. "
}
]
},
{
"day" : 2 ,
"activities" : [
{
"time" : " 10:00 " ,
"activity" : " Visit Senso-ji Temple " ,
"description" : " Explore Tokyo's oldest Buddhist temple and experience traditional Japanese culture. "
},
{
"time" : " 14:00 " ,
"activity" : " Tea Ceremony in Hamarikyu Gardens " ,
"description" : " Participate in a traditional Japanese tea ceremony in a beautiful garden setting. "
},
{
"time" : " 18:00 " ,
"activity" : " Dinner at Tsukiji Outer Market " ,
"description" : " Enjoy fresh sushi and local delicacies at the world-famous fish market area. "
}
]
},
{
"day" : 3 ,
"activities" : [
{
"time" : " 09:00 " ,
"activity" : " Visit teamLab Borderless " ,
"description" : " Immerse yourself in a digital art museum that blends technology and creativity. "
},
{
"time" : " 13:00 " ,
"activity" : " Ramen Tour in Shinjuku " ,
"description" : " Sample various styles of ramen at some of Tokyo's best ramen shops. "
},
{
"time" : " 16:00 " ,
"activity" : " Shopping in Ginza " ,
"description" : " Explore high-end technology stores and experience Japanese retail innovation. "
}
]
}
]
} const options = {
functionName : 'analyze_stock' ,
model : 'gpt-4o' ,
args : { symbol : 'AAPL' , timeframe : '1 year' } ,
description : 'Analyze the stock performance and provide insights based on the given symbol and timeframe.' ,
outputSchema : {
type : "object" ,
properties : {
symbol : { type : "string" } ,
currentPrice : { type : "number" } ,
yearlyPerformance : { type : "number" } ,
technicalIndicators : {
type : "object" ,
properties : {
RSI : { type : "number" } ,
MACD : {
type : "object" ,
properties : {
value : { type : "number" } ,
signal : { type : "number" } ,
histogram : { type : "number" }
} ,
required : [ "value" , "signal" , "histogram" ]
}
} ,
required : [ "RSI" , "MACD" ]
} ,
recommendation : { type : "string" , enum : [ "Buy" , "Hold" , "Sell" ] }
} ,
required : [ "symbol" , "currentPrice" , "yearlyPerformance" , "technicalIndicators" , "recommendation" ]
}
} ;
const stockAnalysis = await aiFunction ( options ) ;
console . log ( JSON . stringify ( stockAnalysis , null , 2 ) ) ;Sortie attendue:
{
"symbol" : " AAPL " ,
"currentPrice" : 178.25 ,
"yearlyPerformance" : 0.35 ,
"technicalIndicators" : {
"RSI" : 62.5 ,
"MACD" : {
"value" : 2.1 ,
"signal" : 1.8 ,
"histogram" : 0.3
}
},
"recommendation" : " Buy "
} Ces exemples montrent comment utiliser l'assistance de la fonction AI pour diverses tâches, de la génération de contenu à l'analyse des données. Chaque exemple comprend un schéma de schéma outputSchema détaillé (alternant entre le schéma JSON et les formats ZOD), garantissant une sortie structurée et validée du modèle AI.
Utilisez des noms de fonction spécifiques : choisissez des noms de fonction clairs et descriptifs pour aider l'IA à comprendre le contexte.
Fournir des descriptions détaillées : plus vous fournissez de contexte dans la description, mieux l'IA peut comprendre et effectuer la tâche.
Définissez des schémas de retour précis : utilisez des schémas de schémas outputSchema détaillés pour vous assurer d'obtenir la structure de données exacte dont vous avez besoin.
Utiliser des outils pour des tâches complexes : pour les tâches qui nécessitent des calculs spécifiques ou des données externes, définissez des outils personnalisés pour gérer ces aspects.
Gérer les erreurs gracieusement : utilisez les blocs de capture d'essai et envisagez de définir le délai d'expiration approprié et de réessayer pour une gestion des erreurs robuste.
Optimiser pour l'utilisation des jetons : Soyez conscient de la durée de vos invites et envisagez d'utiliser minifyJSON pour de grandes sorties pour réduire la consommation de jetons.
Utilisez le streaming pour des réponses longues : pour les tâches qui peuvent générer de longues réponses, envisagez d'utiliser l'option de streaming pour traiter la réponse en temps réel.
Tirer l'historique de la conversation : Pour les interactions multi-tours, utilisez l'option history pour fournir le contexte des échanges précédents.
Q: Puis-je utiliser ce module avec d'autres fournisseurs d'IA? R: Actuellement, AI Function Helper est conçu pour fonctionner avec les modèles d'Openai. Un support pour d'autres fournisseurs peut être ajouté dans les versions futures.
Q: Comment puis-je déboguer si je n'obtiens pas la sortie attendue? R: Activer le débogage en définissant showDebug: true et ajustement du debugLevel . Cela fournira plus d'informations sur les appels et les réponses de l'API.
Q: Ce module est-il adapté à l'utilisation de la production? R: Oui, mais assurez-vous toujours que vous avez des limites de taux d'erreur et de respect appropriées fixées par OpenAI.
Q: Puis-je l'utiliser pour diffuser de grandes quantités de données? R: Oui, vous pouvez utiliser l'option stream pour gérer efficacement de grandes réponses.
Q: Comment le module gère-t-il en toute sécurité les clés d'API? R: Le module ne gère pas le stockage ou la sécurité des clés de l'API. Il est de votre responsabilité de gérer en toute sécurité et de fournir la clé API lors de la création d'une instance.
Nous avons effectué des tests approfondis sur divers modèles d'IA pour évaluer leur capacité à générer des sorties JSON de complexité variable tout en adhérant aux formats spécifiés. Ces tests aident à démontrer la polyvalence et la fiabilité du module d'assistance de fonction AI sur différents modèles d'IA.
Pour assurer des tests complets sur une large gamme de modèles d'IA, y compris ceux qui ne sont pas directement fournis par OpenAI, nous avons utilisé Litellm comme indicateur indirect. Litellm est un outil puissant qui fournit une interface unifiée pour divers fournisseurs d'IA et modèles locaux (via Olllama), offrant une URL de point de terminaison compatible OpenAI. Cette approche nous a permis d'intégrer et de tester de manière transparente plusieurs modèles d'IA avec notre aide de fonction AI, démontrant sa flexibilité et sa large compatibilité.
| Modèle | Taux de réussite | Durée moyenne |
|---|---|---|
| feux d'artifice / Llama-V3P1-405B-Istruct | 100,00% | 1687.67 ms |
| GROQ / LLAMA-3.1-70B-VERSATILE | 100,00% | 2154.89 ms |
| Claude-3-Haiku-20240307 | 100,00% | 3175,72 ms |
| GPT-3,5-turbo | 88,89% | 3398,67 ms |
| GPT-4O-MINI | 100,00% | 5699,72 ms |
| GPT-4O | 100,00% | 5673.00 ms |
| Claude-3-5-Sonnet-20240620 | 100,00% | 5940,50 ms |
| Gémeaux | 88,89% | 5150,00 ms |
| gemini-1.5-pro | 100,00% | 10066.06 ms |
| GEMMA2: 9B (OLLAMA) | 100,00% | 13368,94 ms |
Les tests couvrent un large éventail de fonctionnalités, des calculs simples à la génération et à l'analyse des données complexes. Certaines des catégories de test comprennent:
Pour les résultats détaillés de chaque cas de test et les performances du modèle, veuillez vous référer aux fichiers suivants:
Si vous souhaitez exécuter les tests vous-même ou contribuer à les améliorer, vous pouvez trouver le script de test dans notre référentiel GitHub:
Ces tests démontrent la capacité de l'assistance de la fonction AI à travailler avec divers modèles d'IA et à gérer un large éventail de complexités de tâches. Ils présentent également la capacité du module à appliquer des sorties structurées, ce qui facilite l'intégration du contenu généré par l'IA dans vos applications.
Certains tests sont complexes "stupidement" et sont conçus pour repousser les limites des modèles d'IA. Ces tests ne sont pas censés être pratiques mais plutôt pour démontrer la capacité de l'assistance de la fonction AI à gérer les scénarios difficiles. La plupart des tests échoués peuvent être effectués avec succès en donnant au modèle AI plus de contexte ou en affinant les invites d'entrée.
En tirant parti de LitellM, nous avons élargi la compatibilité de notre aide de fonction AI au-delà des modèles OpenAI, permettant aux utilisateurs de travailler avec un éventail diversifié de fournisseurs d'IA et de modèles locaux tout en conservant une interface cohérente. Cette approche élargit non seulement l'applicabilité de notre outil, mais offre également aux utilisateurs une plus grande flexibilité dans le choix des modèles d'IA qui conviennent le mieux à leurs besoins et contraintes spécifiques.
Les contributions sont les bienvenues! Si vous souhaitez contribuer, veuillez débarquer le référentiel et utiliser une branche de fonctionnalité. Les demandes de traction sont chaleureusement les bienvenues.
L'assistant de fonction AI est un logiciel open d'open sous licence MIT.
