ai fns

AI-FNS

Converta qualquer função em uma função ChatGPT.

AI-FNS é uma pequena biblioteca que converte qualquer função em uma função que possa ser chamada pelo ChatGPT.

As especificações subjacentes são baseadas no novo recurso de chamada de função do OpenAI.

Características

• Mais de 8 funções internas - vem incluído com funções para matemática, RSS, solicitações, relógio e muito mais
• ? 100% -TIPO - Usa Zod para validar a entrada e saída de suas funções
• ? Fácil de usar - API simples que facilita a criação de suas próprias funções
• ? Leve - é uma pequena biblioteca com dependências mínimas

Instalar

pnpm install ai-fns zod

Antes

? ‍? Crie um esquema JSON para sua função manualmente e passe para 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 ,
      } ,
    } ,
  ] ,
} ) ; 

Depois

Use ai-fns para gerar automaticamente um esquema para sua função e passe para 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 ] ,
} ) ; 

Exemplos

(Clique para expandir) (BASIC) Função da calculadora

Aqui está um exemplo de uma função que calcula a saída de uma determinada expressão matemática:

 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 } ` ;
    }
  }
) ;

Agora, você pode apenas pedir a Chatgpt para fazer algumas contas para você:

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

(Clique para expandir) (Avançado) Função Reddit - Obtenha as últimas notícias de qualquer subreddit

Aqui está um exemplo de uma função que recebe as últimas notícias de um 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 que?

O novo recurso de chamada de função do OpenAI permite que você chame funções de dentro do ChatGPT.

No entanto, exige que você passe como esquema JSON para sua função que contém os tipos de entrada e saída da sua função. Isso é um pouco pesado para fazer manualmente.

Esta biblioteca lida automaticamente na conversão para você

Onde posso usar isso?

• ✅ Você está construindo agentes de IA que precisam chamar funções
• ✅ Você deseja que o chatgpt para produzir dados estruturados (por exemplo, JSON)

Contribuindo

Você tem uma ideia para uma função? Sinta -se à vontade para abrir um pedido de tração!

Simplesmente crie um novo arquivo no diretório src/functions e adicione sua função. Certifique -se de adicionar uma descrição e um esquema para sua função.

 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 ) ;