ai function helper
1.0.0
AI Function Helper es un poderoso módulo de nodo.js que simplifica la integración de los modelos GPT de OpenAI en sus aplicaciones. Proporciona una forma estructurada de interactuar con los modelos de IA, asegurando respuestas consistentes y formateadas.
Instale la función AI Helper usando NPM:
npm install ai-function-helperAquí hay un ejemplo simple para comenzar:
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 ) ) ; Para usar la función AI Helper, primero debe crear una instancia con su tecla API OpenAI:
const { createAiFunctionInstance } = require ( 'ai-function-helper' ) ;
const aiFunction = createAiFunctionInstance ( 'your_api_key_here' ) ;También puede usar una URL de punto final personalizado:
const aiFunction = createAiFunctionInstance ( 'your_api_key_here' , 'https://api.openai.com/v1' ) ;Alternativamente, puede usar una instancia de OpenAI existente:
const OpenAI = require ( 'openai' ) ;
const openai = new OpenAI ( { apiKey : 'your_api_key_here' } ) ;
const aiFunction = createAiFunctionInstance ( openai ) ;Una vez que tenga una instancia, puede llamar a las funciones de IA proporcionando opciones:
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" ]
}
} ) ; La aiFunction toma un objeto de opciones con las siguientes propiedades:
| Opción | Tipo | Descripción | Por defecto |
|---|---|---|---|
functionName | cadena | Nombre de la función AI | 'custom_function' |
args | objeto/cadena | Argumentos para la función | - |
description | cadena | Descripción del propósito de la función | - |
outputSchema | objeto | Tipo de retorno esperado (esquema JSON o esquema Zod) | - |
strictReturn | booleano | Hacer cumplir una estricta validación de tipo de retorno | true |
showDebug | booleano | Imprimir información de depuración en la consola | false |
debugLevel | número | Nivel de información de depuración (0-2) | 0 |
temperature | número | Temperatura de muestreo para el modelo AI | 0.6 |
frequency_penalty | número | Penalización de frecuencia para el modelo AI | 0 |
presence_penalty | número | Presencia de penalización para el modelo AI | 0 |
model | cadena | Modelo de IA para usar | 'gpt-4o-mini' |
max_tokens | número | Número máximo de tokens para generar | 1000 |
top_p | número | Valor P superior para el modelo AI | null |
blockHijack | booleano | Evitar secuestro rápido | false |
blockHijackThrowError | booleano | Lanzar error al intento de secuestro | false |
tools | formación | Funciones auxiliares para usar dentro de la función principal | [] |
stream | booleano | Habilitar la transmisión de respuesta | false |
streamCallback | función | Devolución de llamada para respuestas transmitidas | null |
promptVars | objeto | Variables para usar en el aviso | {} |
images | cadena/matriz | URL (s) de imagen para modelos de visión | null |
imageQuality | cadena | Calidad de la imagen para los modelos de visión | 'low' |
minifyJSON | booleano | Minificar la salida de JSON | false |
history | formación | Historia de la conversación para el contexto | [] |
forceJsonMode | booleano | Force el modo JSON para modelos no json | false |
timeout | número | Tiempo de espera para llamadas de API (en milisegundos) | 120000 |
maxRetries | número | Número máximo de reintentos para las llamadas de API | 0 |
includeThinking | booleano | Incluye el proceso de pensamiento de AI en la salida de depuración | false |
OutputSchema : define la estructura esperada de la salida de la función AI utilizando el esquema JSON o el esquema Zod. Esto asegura que el modelo AI devuelva datos en el formato que su aplicación espera.
Herramientas : una variedad de funciones auxiliares que se pueden usar dentro de la función AI principal. Cada herramienta es un objeto con name , function_call , description y propiedades parameters .
Blockhijack : cuando está habilitado, esta característica evita que el modelo AI siga las instrucciones en los mensajes de usuario que intentan anular el comportamiento previsto de la función.
ActivVars : le permite definir variables que se reemplazarán en la descripción de la función, proporcionando más flexibilidad en la ingeniería rápida.
Imágenes : habilita el uso de entradas de imágenes para modelos con capacidad de visión, expandiendo los tipos de tareas que la IA puede realizar.
incluido el tratamiento : cuando se establece en true , esta opción incluye el proceso de pensamiento de la IA en la salida de depuración, proporcionando información sobre cómo llega la IA a sus conclusiones. Esto es particularmente útil para tareas complejas de resolución de problemas y depuración.
La opción includeThinking le permite capturar el proceso de pensamiento de la IA antes de generar la salida final. Esta característica proporciona varios beneficios:
Calidad de respuesta mejorada : al "pensar" antes de responder, la IA puede organizar sus pensamientos y proporcionar respuestas más coherentes y bien estructuradas.
Transparencia : puede ver el razonamiento detrás de las respuestas de la IA, que es útil para depurar y comprender cómo llegó la IA en sus conclusiones.
Ayuda de depuración : el proceso de pensamiento puede ser invaluable al ajustar las indicaciones o la resolución de problemas de resultados inesperados.
Cuando está habilitado, el proceso de pensamiento de la IA se incluye en la salida de depuración, pero no se devuelve como parte del resultado final. Aquí le mostramos cómo usarlo:
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 ) ; En la salida de depuración, verá el proceso de pensamiento encerrado en <|start_of_thinking|> y <|end_of_thinking|> etiquetas. Por ejemplo:
--- 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
}
Tenga en cuenta que el proceso de pensamiento solo es visible en la salida de depuración y no afecta la estructura o contenido del resultado devuelto. Esta característica es particularmente útil para tareas complejas en las que comprender el razonamiento de la IA puede conducir a una mejor ingeniería rápida y resultados más precisos.
En este ejemplo, podemos ver cómo la IA descompone el cálculo complejo en pasos manejables, lo que facilita la verificación del resultado y comprender el enfoque de resolución de problemas. Este nivel de detalle en el proceso de pensamiento puede ser especialmente valioso para la depuración, la educación o cuando los pasos para llegar a una conclusión son tan importantes como la respuesta final en sí.
Habilitar la transmisión para procesar las respuestas en tiempo real:
const options = {
// ... other options ...
stream : true ,
streamCallback : ( chunk ) => {
console . log ( 'Received chunk:' , chunk ) ;
}
} ; La función de transmisión le permite procesar las respuestas de IA en tiempo real, lo que puede ser particularmente útil para tareas de larga duración o cuando desea proporcionar comentarios inmediatos a los usuarios. Aquí hay un ejemplo de cómo usar la opción de stream con 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 ( ) ;En este ejemplo:
stream: true en las opciones para habilitar la transmisión.streamCallback que recibe fragmentos de la respuesta a medida que llegan.Este enfoque le permite manejar la respuesta de la IA en tiempo real, lo que puede ser beneficioso para:
Recuerde que al usar la transmisión, el resultado final devuelto por aiFunction será la respuesta completa, por lo que aún puede usarla si es necesario.
Definir funciones auxiliares para usar dentro de su función AI principal:
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" }
}
}
}
]
} ;Habilitar protección contra el secuestro rápido:
const options = {
// ... other options ...
blockHijack : true ,
blockHijackThrowError : true // Optional: throw error instead of returning a message
} ;Para modelos con capacidad de visión, puede incluir entradas de imágenes:
const options = {
// ... other options ...
images : 'https://example.com/image.jpg' ,
// Or
images : [ 'https://example.com/image1.jpg' , 'https://example.com/image2.jpg' ] ,
imageQuality : 'high'
} ;Proporcionar contexto de interacciones anteriores:
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?" }
]
} ; Aquí hay algunos ejemplos atractivos que muestran la versatilidad y el poder del módulo 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 ) ) ;Salida esperada:
[
{
"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 ) ) ;Salida esperada:
{
"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 ) ) ;Salida esperada:
[
{
"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 ) ) ;Salida esperada:
{
"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 ) ) ;Salida esperada:
{
"symbol" : " AAPL " ,
"currentPrice" : 178.25 ,
"yearlyPerformance" : 0.35 ,
"technicalIndicators" : {
"RSI" : 62.5 ,
"MACD" : {
"value" : 2.1 ,
"signal" : 1.8 ,
"histogram" : 0.3
}
},
"recommendation" : " Buy "
} Estos ejemplos demuestran cómo usar la función AI Helper para varias tareas, desde la generación de contenido hasta el análisis de datos. Cada ejemplo incluye un esquema detallado outputSchema (alternando entre el esquema JSON y los formatos ZOD), asegurando la salida estructurada y validada del modelo AI.
Use nombres de funciones específicos : elija nombres de funciones claros y descriptivos para ayudar a la IA a comprender el contexto.
Proporcione descripciones detalladas : cuanto más contexto proporcione en la descripción, mejor puede comprender y realizar la tarea.
Definir esquemas de retorno precisos : use esquemas detallados outputSchema para asegurarse de obtener la estructura de datos exacta que necesita.
Utilice herramientas para tareas complejas : para tareas que requieren cálculos específicos o datos externos, defina herramientas personalizadas para manejar estos aspectos.
Manejar errores con gracia : use los bloques de prueba de try y considere establecer valores de tiempo de espera y de reintento apropiados para un manejo de errores robusto.
Optimice el uso de tokens : tenga en cuenta la longitud de sus indicaciones y considere usar minifyJSON para grandes resultados para reducir el consumo de token.
Use la transmisión para respuestas largas : para tareas que puedan generar respuestas largas, considere usar la opción de transmisión para procesar la respuesta en tiempo real.
Aproveche el historial de conversación : para las interacciones múltiples, use la opción de history para proporcionar contexto de intercambios anteriores.
P: ¿Puedo usar este módulo con otros proveedores de IA? R: Actualmente, la función AI Helper está diseñada para funcionar con los modelos de OpenAI. El apoyo a otros proveedores se puede agregar en futuras versiones.
P: ¿Cómo puedo depurar si no estoy obteniendo el resultado esperado? R: Habilite la depuración estableciendo showDebug: true y ajustando el debugLevel . Esto proporcionará más información sobre las llamadas y respuestas API.
P: ¿Es este módulo adecuado para el uso de la producción? R: Sí, pero siempre asegúrese de tener el manejo de errores adecuado y los límites de tasa de respeto establecidos por OpenAI.
P: ¿Puedo usar esto para transmitir grandes cantidades de datos? R: Sí, puede usar la opción de stream para manejar respuestas grandes de manera eficiente.
P: ¿Cómo maneja el módulo las teclas API de forma segura? R: El módulo no maneja el almacenamiento o seguridad de la tecla API. Es su responsabilidad administrar de forma segura y proporcionar la clave API al crear una instancia.
Hemos realizado extensas pruebas en varios modelos de IA para evaluar su capacidad para generar salidas JSON de complejidad variable mientras se adhieren a formatos especificados. Estas pruebas ayudan a demostrar la versatilidad y confiabilidad del módulo de ayuda de la función AI en diferentes modelos de IA.
Para garantizar pruebas integrales en una amplia gama de modelos de IA, incluidos los que no son directamente proporcionados por OpenAI, utilizamos litellm como proxy. Litellm es una herramienta poderosa que proporciona una interfaz unificada para varios proveedores de IA y modelos locales (a través de Ollama), que ofrece una URL de punto final compatible con OpenAI. Este enfoque nos permitió integrar y probar múltiples modelos de IA con nuestro ayudante de función de IA, demostrando su flexibilidad y amplia compatibilidad.
| Modelo | Tasa de éxito | Duración promedio |
|---|---|---|
| Fireworks/Llama-V3P1-405B-Instructo | 100.00% | 16887.67ms |
| Groq/Llama-3.1-70b-versátil | 100.00% | 2154.89ms |
| Claude-3-HAIKU-20240307 | 100.00% | 3175.72 ms |
| GPT-3.5-TURBO | 88.89% | 3398.67Ms |
| GPT-4O-Mini | 100.00% | 5699.72 ms |
| GPT-4O | 100.00% | 5673.00ms |
| Claude-3-5-Sonnet-20240620 | 100.00% | 5940.50 ms |
| Géminis-1.5 flash | 88.89% | 5150.00 ms |
| Géminis-1.5-Pro | 100.00% | 10066.06ms |
| Gemma2: 9B (Ollama) | 100.00% | 13368.94ms |
Las pruebas cubren una amplia gama de funcionalidades, desde cálculos simples hasta generación y análisis de datos complejos. Algunas de las categorías de prueba incluyen:
Para obtener resultados detallados de cada caso de prueba y rendimiento del modelo, consulte los siguientes archivos:
Si desea ejecutar las pruebas usted mismo o contribuir a mejorarlas, puede encontrar el script de prueba en nuestro repositorio de GitHub:
Estas pruebas demuestran la capacidad de Helper de la función AI para trabajar con varios modelos de IA y manejar una amplia gama de complejidades de tareas. También muestran la capacidad del módulo para aplicar salidas estructuradas, lo que facilita la integración de contenido generado por IA en sus aplicaciones.
Algunas pruebas son "estúpidamente" complejas y están diseñadas para superar los límites de los modelos AI. Estas pruebas no están destinadas a ser prácticas, sino más bien para demostrar la capacidad de Helper de la función AI para manejar escenarios desafiantes. La mayoría de las pruebas fallidas se pueden completar con éxito dando al modelo AI más contexto o refinando las indicaciones de entrada.
Al aprovechar Litellm, hemos ampliado la compatibilidad de nuestra función de IA Helper más allá de los modelos OpenAI, permitiendo a los usuarios trabajar con una variedad diversa de proveedores de IA y modelos locales mientras mantienen una interfaz consistente. Este enfoque no solo amplía la aplicabilidad de nuestra herramienta, sino que también proporciona a los usuarios una mayor flexibilidad para elegir los modelos de IA que mejor se adaptan a sus necesidades y limitaciones específicas.
¡Las contribuciones son bienvenidas! Si desea contribuir, desembolse el repositorio y use una rama de funciones. Las solicitudes de extracción son cálidamente bienvenidas.
La función AI Helper es un software de código abierto con licencia bajo la licencia MIT.
