modelfusion
v0.137.0
La bibliothèque TypeScript pour créer des applications d'IA.
Introduction | Installation rapide | Utilisation | Documents | Exemples | Contribuer | modelfusion .dev
Important
modelfusion a rejoint Vercel et est en cours d'intégration dans le SDK Vercel AI. Nous apportons les meilleures parties de modelfusion au SDK Vercel AI, en commençant par la génération de texte, la génération d'objets structurés et les appels d'outils. Veuillez consulter le SDK AI pour connaître les derniers développements.
modelfusion est une couche d'abstraction permettant d'intégrer des modèles d'IA dans les applications JavaScript et TypeScript, unifiant l'API pour les opérations courantes telles que le streaming de texte , la génération d'objets et l'utilisation d'outils . Il fournit des fonctionnalités pour prendre en charge les environnements de production, notamment des hooks d'observabilité, la journalisation et les tentatives automatiques. Vous pouvez utiliser modelfusion pour créer des applications d'IA, des chatbots et des agents.
npm install modelfusionOu utilisez un modèle de démarrage :
Conseil
Les exemples de base constituent un excellent moyen de démarrer et d’explorer en parallèle avec la documentation. Vous pouvez les trouver dans le dossier examples/basic.
Vous pouvez fournir des clés API pour les différentes intégrations à l'aide de variables d'environnement (par exemple, OPENAI_API_KEY ) ou les transmettre aux constructeurs de modèles en tant qu'options.
Générez du texte à l’aide d’un modèle de langage et d’une invite. Vous pouvez diffuser le texte s'il est pris en charge par le modèle. Vous pouvez utiliser des images pour les invites multimodales si le modèle le prend en charge (par exemple avec llama.cpp). Vous pouvez utiliser des styles d'invite pour utiliser du texte, des instructions ou des invites de discussion.
import { generateText , openai } from " modelfusion " ;
const text = await generateText ( {
model : openai . CompletionTextGenerator ( { model : "gpt-3.5-turbo-instruct" } ) ,
prompt : "Write a short story about a robot learning to love:nn" ,
} ) ;Fournisseurs : OpenAI, compatible OpenAI, Llama.cpp, Ollama, Mistral, Hugging Face, Cohere
import { streamText , openai } from " modelfusion " ;
const textStream = await streamText ( {
model : openai . CompletionTextGenerator ( { model : "gpt-3.5-turbo-instruct" } ) ,
prompt : "Write a short story about a robot learning to love:nn" ,
} ) ;
for await ( const textPart of textStream ) {
process . stdout . write ( textPart ) ;
}Fournisseurs : OpenAI, compatible OpenAI, Llama.cpp, Ollama, Mistral, Cohere
Les modèles de vision multimodaux tels que GPT 4 Vision peuvent traiter les images dans le cadre de l'invite.
import { streamText , openai } from " modelfusion " ;
import { readFileSync } from "fs" ;
const image = readFileSync ( "./image.png" ) ;
const textStream = await streamText ( {
model : openai
. ChatTextGenerator ( { model : "gpt-4-vision-preview" } )
. withInstructionPrompt ( ) ,
prompt : {
instruction : [
{ type : "text" , text : "Describe the image in detail." } ,
{ type : "image" , image , mimeType : "image/png" } ,
] ,
} ,
} ) ;
for await ( const textPart of textStream ) {
process . stdout . write ( textPart ) ;
}Fournisseurs : OpenAI, compatible OpenAI, Llama.cpp, Ollama
Générez des objets typés à l'aide d'un modèle de langage et d'un schéma.
Générez un objet qui correspond à un schéma.
import {
ollama ,
zodSchema ,
generateObject ,
jsonObjectPrompt ,
} from " modelfusion " ;
const sentiment = await generateObject ( {
model : ollama
. ChatTextGenerator ( {
model : "openhermes2.5-mistral" ,
maxGenerationTokens : 1024 ,
temperature : 0 ,
} )
. asObjectGenerationModel ( jsonObjectPrompt . instruction ( ) ) ,
schema : zodSchema (
z . object ( {
sentiment : z
. enum ( [ "positive" , "neutral" , "negative" ] )
. describe ( "Sentiment." ) ,
} )
) ,
prompt : {
system :
"You are a sentiment evaluator. " +
"Analyze the sentiment of the following product review:" ,
instruction :
"After I opened the package, I was met by a very unpleasant smell " +
"that did not disappear even after washing. Never again!" ,
} ,
} ) ;Fournisseurs : OpenAI, Ollama, Llama.cpp
Diffusez un objet qui correspond à un schéma. Les objets partiels avant la partie finale sont des JSON non typés.
import { zodSchema , openai , streamObject } from " modelfusion " ;
const objectStream = await streamObject ( {
model : openai
. ChatTextGenerator ( /* ... */ )
. asFunctionCallObjectGenerationModel ( {
fnName : "generateCharacter" ,
fnDescription : "Generate character descriptions." ,
} )
. withTextPrompt ( ) ,
schema : zodSchema (
z . object ( {
characters : z . array (
z . object ( {
name : z . string ( ) ,
class : z
. string ( )
. describe ( "Character class, e.g. warrior, mage, or thief." ) ,
description : z . string ( ) ,
} )
) ,
} )
) ,
prompt : "Generate 3 character descriptions for a fantasy role playing game." ,
} ) ;
for await ( const { partialObject } of objectStream ) {
console . clear ( ) ;
console . log ( partialObject ) ;
}Fournisseurs : OpenAI, Ollama, Llama.cpp
Générez une image à partir d'une invite.
import { generateImage , openai } from " modelfusion " ;
const image = await generateImage ( {
model : openai . ImageGenerator ( { model : "dall-e-3" , size : "1024x1024" } ) ,
prompt :
"the wicked witch of the west in the style of early 19th century painting" ,
} ) ;Fournisseurs : OpenAI (Dall·E), Stability AI, Automatic1111
Synthétiser la parole (audio) à partir du texte. Également appelé TTS (text-to-speech).
generateSpeech synthétise la parole à partir du texte.
import { generateSpeech , lmnt } from " modelfusion " ;
// `speech` is a Uint8Array with MP3 audio data
const speech = await generateSpeech ( {
model : lmnt . SpeechGenerator ( {
voice : "034b632b-df71-46c8-b440-86a42ffc3cf3" , // Henry
} ) ,
text :
"Good evening, ladies and gentlemen! Exciting news on the airwaves tonight " +
"as The Rolling Stones unveil 'Hackney Diamonds,' their first collection of " +
"fresh tunes in nearly twenty years, featuring the illustrious Lady Gaga, the " +
"magical Stevie Wonder, and the final beats from the late Charlie Watts." ,
} ) ;Fournisseurs : Eleven Labs, LMNT, OpenAI
generateSpeech génère un flux de morceaux de parole à partir de texte ou d'un flux de texte. Selon le modèle, cela peut être entièrement duplex.
import { streamSpeech , elevenlabs } from " modelfusion " ;
const textStream : AsyncIterable < string > ;
const speechStream = await streamSpeech ( {
model : elevenlabs . SpeechGenerator ( {
model : "eleven_turbo_v2" ,
voice : "pNInz6obpgDQGcFmaJgB" , // Adam
optimizeStreamingLatency : 1 ,
voiceSettings : { stability : 1 , similarityBoost : 0.35 } ,
generationConfig : {
chunkLengthSchedule : [ 50 , 90 , 120 , 150 , 200 ] ,
} ,
} ) ,
text : textStream ,
} ) ;
for await ( const part of speechStream ) {
// each part is a Uint8Array with MP3 audio data
}Fournisseurs : Eleven Labs
Transcrivez les données vocales (audio) en texte. Également appelé synthèse vocale (STT).
import { generateTranscription , openai } from " modelfusion " ;
import fs from "node:fs" ;
const transcription = await generateTranscription ( {
model : openai . Transcriber ( { model : "whisper-1" } ) ,
mimeType : "audio/mp3" ,
audioData : await fs . promises . readFile ( "data/test.mp3" ) ,
} ) ;Fournisseurs : OpenAI (Whisper), Whisper.cpp
Créez des intégrations pour le texte et d’autres valeurs. Les plongements sont des vecteurs qui représentent l'essence des valeurs dans le contexte du modèle.
import { embed , embedMany , openai } from " modelfusion " ;
// embed single value:
const embedding = await embed ( {
model : openai . TextEmbedder ( { model : "text-embedding-ada-002" } ) ,
value : "At first, Nox didn't know what to do with the pup." ,
} ) ;
// embed many values:
const embeddings = await embedMany ( {
model : openai . TextEmbedder ( { model : "text-embedding-ada-002" } ) ,
values : [
"At first, Nox didn't know what to do with the pup." ,
"He keenly observed and absorbed everything around him, from the birds in the sky to the trees in the forest." ,
] ,
} ) ;Fournisseurs : OpenAI, compatible OpenAI, Llama.cpp, Ollama, Mistral, Hugging Face, Cohere
Classe une valeur dans une catégorie.
import { classify , EmbeddingSimilarityClassifier , openai } from " modelfusion " ;
const classifier = new EmbeddingSimilarityClassifier ( {
embeddingModel : openai . TextEmbedder ( { model : "text-embedding-ada-002" } ) ,
similarityThreshold : 0.82 ,
clusters : [
{
name : "politics" as const ,
values : [
"they will save the country!" ,
// ...
] ,
} ,
{
name : "chitchat" as const ,
values : [
"how's the weather today?" ,
// ...
] ,
} ,
] ,
} ) ;
// strongly typed result:
const result = await classify ( {
model : classifier ,
value : "don't you love politics?" ,
} ) ;Classificateurs : EmbeddingSimilarityClassifier
Divisez le texte en jetons et reconstruisez le texte à partir de jetons.
const tokenizer = openai . Tokenizer ( { model : "gpt-4" } ) ;
const text = "At first, Nox didn't know what to do with the pup." ;
const tokenCount = await countTokens ( tokenizer , text ) ;
const tokens = await tokenizer . tokenize ( text ) ;
const tokensAndTokenTexts = await tokenizer . tokenizeWithTexts ( text ) ;
const reconstructedText = await tokenizer . detokenize ( tokens ) ;Fournisseurs : OpenAI, Llama.cpp, Cohere
Les outils sont des fonctions (et les métadonnées associées) qui peuvent être exécutées par un modèle d'IA. Ils sont utiles pour créer des chatbots et des agents.
modelfusion propose plusieurs outils prêts à l'emploi : Math.js, MediaWiki Search, SerpAPI, Google Custom Search. Vous pouvez également créer des outils personnalisés.
Avec runTool , vous pouvez demander à un modèle de langage compatible avec les outils (par exemple le chat OpenAI) d'invoquer un seul outil. runTool génère d'abord un appel d'outil, puis exécute l'outil avec les arguments.
const { tool , toolCall , args , ok , result } = await runTool ( {
model : openai . ChatTextGenerator ( { model : "gpt-3.5-turbo" } ) ,
too : calculator ,
prompt : [ openai . ChatMessage . user ( "What's fourteen times twelve?" ) ] ,
} ) ;
console . log ( `Tool call:` , toolCall ) ;
console . log ( `Tool:` , tool ) ;
console . log ( `Arguments:` , args ) ;
console . log ( `Ok:` , ok ) ;
console . log ( `Result or Error:` , result ) ; Avec runTools , vous pouvez demander à un modèle de langage de générer plusieurs appels d'outils ainsi que du texte. Le modèle choisira quels outils (le cas échéant) doivent être appelés avec quels arguments. Le texte et les appels d’outils sont facultatifs. Cette fonction exécute les outils.
const { text , toolResults } = await runTools ( {
model : openai . ChatTextGenerator ( { model : "gpt-3.5-turbo" } ) ,
tools : [ calculator /* ... */ ] ,
prompt : [ openai . ChatMessage . user ( "What's fourteen times twelve?" ) ] ,
} ) ; Vous pouvez utiliser runTools pour implémenter une boucle d'agent qui répond aux messages utilisateur et exécute les outils. Apprendre encore plus.
const texts = [
"A rainbow is an optical phenomenon that can occur under certain meteorological conditions." ,
"It is caused by refraction, internal reflection and dispersion of light in water droplets resulting in a continuous spectrum of light appearing in the sky." ,
// ...
] ;
const vectorIndex = new MemoryVectorIndex < string > ( ) ;
const embeddingModel = openai . TextEmbedder ( {
model : "text-embedding-ada-002" ,
} ) ;
// update an index - usually done as part of an ingestion process:
await upsertIntoVectorIndex ( {
vectorIndex ,
embeddingModel ,
objects : texts ,
getValueToEmbed : ( text ) => text ,
} ) ;
// retrieve text chunks from the vector index - usually done at query time:
const retrievedTexts = await retrieve (
new VectorIndexRetriever ( {
vectorIndex ,
embeddingModel ,
maxResults : 3 ,
similarityThreshold : 0.8 ,
} ) ,
"rainbow and water droplets"
) ;Magasins de vecteurs disponibles : mémoire, SQLite VSS, Pinecone
Vous pouvez utiliser différents styles d'invite (tels que du texte, des instructions ou des invites de discussion) avec les modèles de génération de texte modelfusion . Ces styles d'invite sont accessibles via les méthodes .withTextPrompt() , .withChatPrompt() et .withInstructionPrompt() :
const text = await generateText ( {
model : openai
. ChatTextGenerator ( {
// ...
} )
. withTextPrompt ( ) ,
prompt : "Write a short story about a robot learning to love" ,
} ) ; const text = await generateText ( {
model : llamacpp
. CompletionTextGenerator ( {
// run https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGUF with llama.cpp
promptTemplate : llamacpp . prompt . Llama2 , // Set prompt template
contextWindowSize : 4096 , // Llama 2 context window size
maxGenerationTokens : 512 ,
} )
. withInstructionPrompt ( ) ,
prompt : {
system : "You are a story writer." ,
instruction : "Write a short story about a robot learning to love." ,
} ,
} ) ; const textStream = await streamText ( {
model : openai
. ChatTextGenerator ( {
model : "gpt-3.5-turbo" ,
} )
. withChatPrompt ( ) ,
prompt : {
system : "You are a celebrated poet." ,
messages : [
{
role : "user" ,
content : "Suggest a name for a robot." ,
} ,
{
role : "assistant" ,
content : "I suggest the name Robbie" ,
} ,
{
role : "user" ,
content : "Write a short story about Robbie learning to love" ,
} ,
] ,
} ,
} ) ;Vous pouvez également utiliser des modèles d'invite avec des modèles d'image, par exemple pour utiliser une invite textuelle de base. Il est disponible sous forme de méthode abrégée :
const image = await generateImage ( {
model : stability
. ImageGenerator ( {
//...
} )
. withTextPrompt ( ) ,
prompt :
"the wicked witch of the west in the style of early 19th century painting" ,
} ) ;| Modèle d'invite | Invite de texte |
|---|---|
| Automatique1111 | ✅ |
| Stabilité | ✅ |
Les fonctions de modèle modelfusion renvoient des réponses riches qui incluent la réponse brute (originale) et les métadonnées lorsque vous définissez l'argument fullResponse sur true .
// access the raw response (needs to be typed) and the metadata:
const { text , rawResponse , metadata } = await generateText ( {
model : openai . CompletionTextGenerator ( {
model : "gpt-3.5-turbo-instruct" ,
maxGenerationTokens : 1000 ,
n : 2 , // generate 2 completions
} ) ,
prompt : "Write a short story about a robot learning to love:nn" ,
fullResponse : true ,
} ) ;
console . log ( metadata ) ;
// cast to the raw response type:
for ( const choice of ( rawResponse as OpenAICompletionResponse ) . choices ) {
console . log ( choice . text ) ;
}modelfusion fournit un cadre d'observateur et un support de journalisation. Vous pouvez facilement tracer des exécutions et appeler des hiérarchies, et vous pouvez ajouter vos propres observateurs.
import { generateText , openai } from " modelfusion " ;
const text = await generateText ( {
model : openai . CompletionTextGenerator ( { model : "gpt-3.5-turbo-instruct" } ) ,
prompt : "Write a short story about a robot learning to love:nn" ,
logging : "detailed-object" ,
} ) ; Exemples pour presque toutes les fonctions et objets individuels. Fortement recommandé pour commencer.
multimodal , streaming d'objets , génération d'images , synthèse vocale , synthèse vocale , génération de texte , génération d'objets , intégrations
StoryTeller est une application Web exploratoire qui crée de courtes histoires audio pour les enfants d'âge préscolaire.
Application Next.js , OpenAI GPT-3.5-turbo , streaming , gestion des abandons
Un chat Web avec un assistant IA, implémenté sous la forme d'une application Next.js.
application de terminal , analyse PDF , indices vectoriels en mémoire , génération augmentée de récupération , intégration de documents hypothétiques
Posez des questions sur un document PDF et obtenez des réponses à partir du document.
Application Next.js , génération d'images , transcription , streaming d'objets , OpenAI , Stability AI , Ollama
Exemples d'utilisation modelfusion avec Next.js 14 (App Router) :
Streaming vocal , OpenAI , streaming Elevenlabs , Vite , Fastify , modelfusion Server
Suite à une invite, le serveur renvoie à la fois une réponse textuelle et une réponse vocale.
application de terminal , agent , BabyAGI
Implémentation TypeScript du classique BabyAGI et BabyBeeAGI.
application de terminal , agent ReAct , GPT-4 , fonctions OpenAI , outils
Obtenez des réponses aux questions de Wikipédia, par exemple « Qui est né en premier, Einstein ou Picasso ? »
application de terminal , agent , outils , GPT-4
Petit agent qui résout les problèmes de mathématiques du collège. Il utilise un outil de calcul pour résoudre les problèmes.
application de terminal , analyse PDF , extraction d'informations récursive , index vectoriel en mémoire, récupération d'exemple _style , OpenAI GPT-4 , calcul des coûts
Extrait des informations sur un sujet à partir d'un PDF et rédige un tweet dans votre propre style à ce sujet.
Cloudflare , OpenAI
Générez du texte sur un Cloudflare Worker à l'aide de modelfusion et OpenAI.
Lisez le guide de contribution modelfusion pour en savoir plus sur le processus de développement, comment proposer des corrections de bugs et des améliorations, et comment créer et tester vos modifications.
