ai fns

AI-FNS

Convertissez n'importe quelle fonction en une fonction Chatgpt.

AI-FNS est une petite bibliothèque qui convertit n'importe quelle fonction en une fonction qui peut être appelée par Chatgpt.

La spécification sous-jacente est basée sur la nouvelle fonction d'appel de fonction d'OpenAI.

Caractéristiques

• 8+ fonctions intégrées - Livré avec des fonctions pour les mathématiques, les RSS, les demandes, l'horloge et plus
• ? 100% type-sécurité - utilise ZOD pour valider l'entrée et la sortie de vos fonctions
• ? Facile à utiliser - API simple qui facilite la création de vos propres fonctions
• ? Léger - est une petite bibliothèque avec des dépendances minimales

Installer

pnpm install ai-fns zod

Avant

? ‍? Créez un schéma JSON pour votre fonction manuellement et passez-le à 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 ,
      } ,
    } ,
  ] ,
} ) ; 

Après

Utilisez ai-fns pour générer automatiquement un schéma pour votre fonction et passer à 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 ] ,
} ) ; 

Exemples

(Cliquez pour développer) (BASIC) Fonction de calculatrice

Voici un exemple de fonction qui calcule la sortie d'une expression mathématique donnée:

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

Maintenant, vous pouvez simplement demander à Chatgpt de faire des calculs pour vous:

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

(Cliquez pour agrandir) (Advanced) Reddit Fonction - Obtenez les dernières nouvelles à partir de tout SousBredit

Voici un exemple de fonction qui récupère les dernières nouvelles d'un flux 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.

Pourquoi?

La nouvelle fonction d'appel de fonction d'Openai vous permet d'appeler des fonctions à partir de Chatgpt.

Cependant, cela vous oblige à passer en tant que schéma JSON pour votre fonction contenant les types d'entrée et de sortie de votre fonction. C'est un peu lourd à faire manuellement.

Cette bibliothèque gère automatiquement la conversion pour vous

Où puis-je utiliser ceci?

• ✅ Vous construisez des agents d'IA qui doivent appeler des fonctions
• ✅ Vous voulez que le chatppt sortira des données structurées (par exemple JSON)

Contributif

Avez-vous une idée pour une fonction? N'hésitez pas à ouvrir une demande de traction!

Créez simplement un nouveau fichier dans le répertoire src/functions et ajoutez votre fonction. Assurez-vous d'ajouter une description et un schéma pour votre fonction.

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