ai fns

ai-fns

Convierta cualquier función en una función de chatgpt.

AI-FNS es una pequeña biblioteca que convierte cualquier función en una función que ChatGPT pueda llamar por ChatGPT.

La especificación subyacente se basa en la nueva función de llamadas de funciones de Openai.

Características

• 8+ Funciones integradas : se incluye con funciones para matemáticas, RSS, solicitudes, reloj y más
• ? 100% Type -Safe : usa Zod para validar la entrada y la salida de sus funciones
• ? Fácil de usar - API simple que facilita la creación de sus propias funciones
• ? Ligero : es una pequeña biblioteca con dependencias mínimas

Instalar

pnpm install ai-fns zod

Antes

? ‍? Crea un esquema JSON para tu función manualmente y páselo a chatgpt

 import openai , { OpenAI } from "openai" ;

const openai = new OpenAI ( {
  apiKey : env . OPENAI_API_KEY ,
} ) ;

const weather = async ( {
  latitude ,
  longitude ,
} : {
  latitude : number ;
  longitude : number ;
} ) => {
  try {
    const res = await fetch (
      `https://api.open-meteo.com/v1/forecast?latitude= ${ latitude } &longitude= ${ longitude } &current_weather=true`
    ) ;
    return await res . json ( ) ;
  } catch ( error ) {
    return error ;
  }
} ;

const completion = await openai . chat . completions . create ( {
  model : "gpt-3.5-turbo-16k" ,
  messages : [ { role : "user" , content : "What's the weather in San Francisco?" } ] ,
  functions : [
    {
      name : "weather" ,
      description : "Get the current weather in a given location" ,
      parameters : {
        type : "object" ,
        properties : {
          longitude : {
            type : "number" ,
            minimum : - 180 ,
            maximum : 180 ,
            description : "Longitude" ,
          } ,
          latitude : {
            type : "number" ,
            minimum : - 90 ,
            maximum : 90 ,
            description : "Latitude" ,
          } ,
        } ,
        required : [ "longitude" , "latitude" ] ,
        additionalProperties : false ,
      } ,
    } ,
  ] ,
} ) ; 

Después

Use ai-fns para generar automáticamente un esquema para su función y pasarlo a chatgpt

 import openai , { OpenAI } from "openai" ;
import { z } from "zod" ;
import { aifn } from "ai-fns" ;

const openai = new OpenAI ( {
  apiKey : env . OPENAI_API_KEY ,
} ) ;

const { schema , fn } = aifn (
  "weather" ,
  "Get the current weather in a given location" ,
  z . object ( {
    longitude : z . number ( ) . min ( - 180 ) . max ( 180 ) . describe ( "Longitude" ) ,
    latitude : z . number ( ) . min ( - 90 ) . max ( 90 ) . describe ( "Latitude" ) ,
  } ) ,
  async ( { latitude , longitude } ) => {
    try {
      const res = await fetch (
        `https://api.open-meteo.com/v1/forecast?latitude= ${ latitude } &longitude= ${ longitude } &current_weather=true`
      ) ;
      return await res . json ( ) ;
    } catch ( error ) {
      return error ;
    }
  }
) ;

// Ask the AI a question
const completion = await openai . chat . completions . create ( {
  model : "gpt-3.5-turbo-16k" ,
  messages : [ { role : "user" , content : "What's the weather in San Francisco?" } ] ,
  functions : [ schema ] ,
} ) ; 

Ejemplos

(Haga clic para expandir) (básico) función de calculadora

Aquí hay un ejemplo de una función que calcula la salida de una expresión matemática dada:

 import { Parser } from "expr-eval" ;
import { z } from "zod" ;
import { aifn } from "ai-fns" ;

const parser = new Parser ( ) ;

export default aifn (
  "calculator" ,
  "Calculate the output of a given mathematical expression" ,
  z . object ( {
    expression : z . string ( ) ,
  } ) ,
  ( { expression } ) => {
    try {
      const result = parser . parse ( expression ) . evaluate ( ) ;
      return result ;
    } catch ( error ) {
      return `Failed to execute script: ${ error . message } ` ;
    }
  }
) ;

Ahora, puede pedirle a ChatGPT que haga un poco de matemáticas por usted:

 User: What's 45^(2.12) / 45?
Assistant: The result of 45^(2.12) / 45 is approximately 71.06.

(Haga clic para expandir) (avanzado) Función Reddit: obtenga las últimas noticias de cualquier subreddit

Aquí hay un ejemplo de una función que obtiene las últimas noticias de un feed RSS:

 import { z } from "zod" ;
import { aifn } from "ai-fns" ;

const name = "reddit" ;
const description = "Get stories from reddit" ;
const schema = z . object ( {
  subreddit : z . string ( ) . optional ( ) . default ( "all" ) . describe ( "Subreddit" ) ,
  limit : z . number ( ) . optional ( ) . default ( 5 ) . describe ( "Limit" ) ,
  category : z
    . enum ( [ "hot" , "new" , "random" , "top" , "rising" , "controversial" ] )
    . default ( "hot" )
    . describe ( "category" ) ,
} ) ;

const reddit = async ( {
  subreddit ,
  category ,
  limit ,
} : z . infer < typeof schema > ) => {
  try {
    const params = new URLSearchParams ( {
      limit : limit . toString ( ) ,
    } ) ;
    const url = `https://www.reddit.com/r/ ${ subreddit } / ${ category } .json? ${ params . toString ( ) } ` ;
    const res = await fetch ( url ) ;
    return await res . json ( ) ;
  } catch ( error ) {
    console . log ( error ) ;
    return error ;
  }
} ;

export default aifn ( name , description , schema , reddit ) ; 

 User: What's the top story on /r/programming today?
Assistant: The top story on /r/programming is "Crumb: A New Programming Language Where There are No Keywords, and Everything is a Function". You can read more about it [here](https://github.com/liam-ilan/crumb). It has received 201 upvotes and has 25 comments.

¿Por qué?

La nueva función de llamadas de funciones de Openai le permite llamar a las funciones desde ChatGPT.

Sin embargo, requiere que pase como esquema JSON para su función que contiene los tipos de entrada y salida de su función. Esto es un poco engorroso de hacer manualmente.

Esta biblioteca maneja automáticamente la conversión para usted

¿Dónde puedo usar esto?

• ✅ Estás construyendo agentes de IA que necesitan llamar a las funciones
• ✅ Desea que ChatGPT salga de datos estructurados (por ejemplo, JSON)

Que contribuye

¿Tienes una idea para una función? ¡No dude en abrir una solicitud de extracción!

Simplemente cree un nuevo archivo en el directorio src/functions y agregue su función. Asegúrese de agregar una descripción y un esquema para su función.

 import { z } from "zod" ;
import { aifn } from "ai-fns" ;

export const name = "name" ;
export const description = "description" ;
export const schema = z . object ( {
  // schema
} ) ;
export const fn = async ( { } : /* schema */ z . infer < typeof schema > ) => {
  // function body
} ;

export default aifn ( name , description , schema , fn ) ;