llm.js
1.0.0
LLM.js est le moyen le plus rapide d'utiliser les grands modèles de langage en JavaScript. Il s'agit d'une interface simple et unique vers des centaines de LLM populaires :
gpt-4 , gpt-4-turbo-preview , gpt-3.5-turbogemini-1.5-pro , gemini-1.0-pro , gemini-pro-visionclaude-3-opus , claude-3-sonnet , claude-3-haiku , claude-2.1 , claude-instant-1.2mixtral-8x7b , llama2-70b , gemma-7b-itllama-3-70b , llama-3-8b , nous-hermes-2 , ...mistral-medium , mistral-small , mistral-tinyLLaVa-1.5 , TinyLlama-1.1B , Phi-2 , ...llama-3 , llama-2 , gemma , dolphin-phi , ... await LLM ( "the color of the sky is" , { model : "gpt-4" } ) ; // blueCaractéristiques
OpenAI , Google , Anthropic , Mistral , Groq , Llamafile , Ollama , Together )temperature , max_tokens , seed , ...)llm pour votre shell Installez LLM.js à partir de NPM :
npm install @themaximalist/llm.jsLa configuration des LLM est simple : assurez-vous simplement que votre clé API est définie dans votre environnement
export OPENAI_API_KEY=...
export ANTHROPIC_API_KEY=...
export MISTRAL_API_KEY=...
export GOOGLE_API_KEY=...
export GROQ_API_KEY=...
export TOGETHER_API_KEY=...Pour les modèles locaux comme llamafile et Ollama, assurez-vous qu'une instance est en cours d'exécution.
La façon la plus simple d'appeler LLM.js est d'utiliser une async function .
const LLM = require ( "@themaximalist/llm.js" ) ;
await LLM ( "hello" ) ; // Response: hiCela déclenche une requête unique et ne stocke aucun historique.
Initialisez une instance LLM pour créer un historique des messages.
const llm = new LLM ( ) ;
await llm . chat ( "what's the color of the sky in hex value?" ) ; // #87CEEB
await llm . chat ( "what about at night time?" ) ; // #222d5a Le streaming offre une meilleure expérience utilisateur en renvoyant les résultats immédiatement, et c'est aussi simple que de transmettre {stream: true} comme option.
const stream = await LLM ( "the color of the sky is" , { stream : true } ) ;
for await ( const message of stream ) {
process . stdout . write ( message ) ;
}Parfois, il est utile de gérer le flux en temps réel et de le traiter une fois qu'il est terminé. Par exemple, fournir une diffusion en temps réel dans le chat, puis analyser les blocs de code sémantique à la fin.
LLM.js facilite cela avec une option stream_handler facultative.
const colors = await LLM ( "what are the common colors of the sky as a flat json array?" , {
model : "gpt-4-turbo-preview" ,
stream : true ,
stream_handler : ( c ) => process . stdout . write ( c ) ,
parser : LLM . parsers . json ,
} ) ;
// ["blue", "gray", "white", "orange", "red", "pink", "purple", "black"] Au lieu que le flux soit renvoyé en tant que générateur, il est transmis au stream_handler . La réponse de LLM.js est la réponse complète, qui peut être analysée ou gérée normalement.
LLM.js prend en charge le schéma JSON pour OpenAI et LLaMa. Vous pouvez demander JSON avec n'importe quel modèle LLM, mais l'utilisation du schéma JSON appliquera les sorties.
const schema = {
"type" : "object" ,
"properties" : {
"colors" : { "type" : "array" , "items" : { "type" : "string" } }
}
}
const obj = await LLM ( "what are the 3 primary colors in JSON format?" , { schema , temperature : 0.1 , service : "openai" } ) ; Différents formats sont utilisés par différents modèles (schéma JSON, BNFS), donc LLM.js convertit automatiquement entre eux.
Notez que le schéma JSON peut toujours produire un JSON non valide, par exemple lorsqu'il dépasse max_tokens .
Créez des agents spécialisés dans des tâches spécifiques à l'aide llm.system(input) .
const llm = new LLM ( ) ;
llm . system ( "You are a friendly chat bot." ) ;
await llm . chat ( "what's the color of the sky in hex value?" ) ; // Response: sky blue
await llm . chat ( "what about at night time?" ) ; // Response: darker value (uses previous context to know we're asking for a color) Notez qu'OpenAI a suggéré que les invites système pourraient ne pas être aussi efficaces que les invites utilisateur, que LLM.js prend en charge avec llm.user(input) .
LLM.js prend en charge les invites de chaîne simples, mais également l'historique complet des messages. Ceci est particulièrement utile pour guider les LLM de manière plus précise.
await LLM ( [
{ role : "user" , content : "remember the secret codeword is blue" } ,
{ role : "assistant" , content : "OK I will remember" } ,
{ role : "user" , content : "what is the secret codeword I just told you?" } ,
] ) ; // Response: blueLe format de message OpenAI est utilisé et converti à la volée pour des services spécifiques utilisant un format différent (comme Google, Mixtral et LLaMa).
LLM.js prend en charge les modèles de grands langages les plus populaires, notamment
gpt-4 , gpt-4-turbo-preview , gpt-3.5-turbogemini-1.0-pro , gemini-1.5-pro , gemini-pro-visionclaude-3-sonnet , claude-3-haiku , claude-2.1 , claude-instant-1.2mixtral-8x7b , llama2-70b , gemma-7b-itllama-3-70b , llama-3-8b , nous-hermes-2 , ...mistral-medium , mistral-small , mistral-tinyLLaVa 1.5 , Mistral-7B-Instruct , Mixtral-8x7B-Instruct , WizardCoder-Python-34B , TinyLlama-1.1B , Phi-2 , ...Llama 2 , Mistral , Code Llama , Gemma , Dolphin Phi , ... LLM.js peut deviner le fournisseur LLM en fonction du modèle, ou vous pouvez le spécifier explicitement.
// defaults to Llamafile
await LLM ( "the color of the sky is" ) ;
// OpenAI
await LLM ( "the color of the sky is" , { model : "gpt-4-turbo-preview" } ) ;
// Anthropic
await LLM ( "the color of the sky is" , { model : "claude-2.1" } ) ;
// Mistral AI
await LLM ( "the color of the sky is" , { model : "mistral-tiny" } ) ;
// Groq needs an specific service
await LLM ( "the color of the sky is" , { service : "groq" , model : "mixtral-8x7b-32768" } ) ;
// Google
await LLM ( "the color of the sky is" , { model : "gemini-pro" } ) ;
// Ollama
await LLM ( "the color of the sky is" , { model : "llama2:7b" } ) ;
// Together
await LLM ( "the color of the sky is" , { service : "together" , model : "meta-llama/Llama-3-70b-chat-hf" } ) ;
// Can optionally set service to be specific
await LLM ( "the color of the sky is" , { service : "openai" , model : "gpt-3.5-turbo" } ) ;Être capable de basculer rapidement entre les LLM vous évite de vous enfermer.
LLM.js est livré avec quelques analyseurs utiles qui fonctionnent avec chaque LLM. Ceux-ci sont distincts du formatage JSON typique avec tool et schema pris en charge par certains LLM (comme ceux d'OpenAI).
Analyse JSON
const colors = await LLM ( "Please return the primary colors in a JSON array" , {
parser : LLM . parsers . json
} ) ;
// ["red", "green", "blue"]Analyse des blocs de code Markdown
const story = await LLM ( "Please return a story wrapped in a Markdown story code block" , {
parser : LLM . parsers . codeBlock ( "story" )
} ) ;
// A long time ago...Analyse XML
const code = await LLM ( "Please write a simple website, and put the code inside of a <WEBSITE></WEBSITE> xml tag" {
parser : LLM . parsers . xml ( "WEBSITE" )
} ) ;
// <html>....Remarque : OpenAI fonctionne mieux avec Markdown et JSON, tandis qu'Anthropic fonctionne mieux avec les balises XML.
L'API LLM.js fournit une interface simple pour des dizaines de grands modèles de langage.
new LLM ( input , { // Input can be string or message history array
service : "openai" , // LLM service provider
model : "gpt-4" , // Specific model
max_tokens : 100 , // Maximum response length
temperature : 1.0 , // "Creativity" of model
seed : 1000 , // Stable starting point
stream : false , // Respond in real-time
stream_handler : null , // Optional function to handle stream
schema : { ... } , // JSON Schema
tool : { ... } , // Tool selection
parser : null , // Content parser
} ) ; La même API est prise en charge dans l'interface abrégée de LLM.js en l'appelant en tant que fonction :
await LLM ( input , options ) ;Entrée (obligatoire)
input <string> ou Array : Invite pour LLM. Il peut s'agir d'une chaîne de texte ou d'un tableau d'objets au format Message History .Possibilités
Tous les paramètres de configuration sont facultatifs. Certaines options de configuration ne sont disponibles que sur certains modèles et sont spécifiées ci-dessous.
service <string> : service LLM à utiliser. La valeur par défaut est llamafile .model <string> : LLM explicite à utiliser. La valeur par défaut est le modèle par défaut service .max_tokens <int> : longueur maximale de réponse du jeton. Aucun défaut.temperature <float> : "Créativité" d'un modèle. 0 donne généralement des résultats plus déterministes, et des valeurs plus élevées, 1 et supérieures, donnent des résultats moins déterministes. Aucun défaut.seed <int> : Obtenez des résultats plus déterministes. Aucun défaut. Pris en charge par openai , llamafile et mistral .stream <bool> : renvoie les résultats immédiatement au lieu d'attendre une réponse complète. La valeur par défaut est false .stream_handler <function> : fonction facultative appelée lorsqu'un flux reçoit un nouveau contenu. La fonction reçoit le morceau de chaîne.schema <object> : Objet de schéma JSON pour piloter LLM afin de générer du JSON. Aucun défaut. Pris en charge par openai et llamafile .tool <object> : demandez à LLM d'utiliser un outil, utile pour un schéma JSON plus explicite et la création d'applications dynamiques. Aucun défaut. Pris en charge par openai .parser <function> : Gère le formatage et la structure du contenu renvoyé. Aucun défaut.messages <array> : Tableau de l'historique des messages, géré par LLM.js — mais peut être référencé et modifié.options <object> : configuration des options définie au démarrage, mais pouvant être modifiée dynamiquement.async send(options=<object>) Envoie l' Message History actuel au LLM actuel avec options spécifiées. Ces options locales remplaceront les options globales par défaut.
La réponse sera automatiquement ajoutée à Message History .
await llm . send ( options ) ; async chat(input=<string>, options=<object>) Ajoute l' input à l' Message History actuel et appelle send avec les options de remplacement actuelles.
Renvoie la réponse directement à l'utilisateur, lors de la mise à jour de Message History .
const response = await llm . chat ( "hello" ) ;
console . log ( response ) ; // hi abort() Abandonne un flux en cours. Lève une AbortError .
user(input=<string>) Ajoute un message de user à Message History .
llm . user ( "My favorite color is blue. Remember that" ) ; system(input=<string>) Ajoute un message du system à Message History . Il s'agit généralement du premier message.
llm . system ( "You are a friendly AI chat bot..." ) ; assistant(input=<string>) Ajoute un message de assistant à Message History . Il s’agit généralement d’une réponse de l’IA ou d’un moyen d’orienter une réponse future.
llm . user ( "My favorite color is blue. Remember that" ) ;
llm . assistant ( "OK, I will remember your favorite color is blue." ) ;LLAMAFILE <string> : llamafileOPENAI <string> : openaiANTHROPIC <string> : anthropicMISTRAL <string> : mistralGOOGLE <string> : googleMODELDEPLOYER <string> : modeldeployerOLLAMA <string> : ollamaTOGETHER <string> : togetherparsers <object> : Liste des analyseurs LLM.js par défaut<blockType> )( <content> ) <function> — Analyse un bloc de code Markdown<content> ) <function> — Analyse le JSON global ou un bloc de code Markdown JSON<tag> )( <content> ) <function> — Analyse la balise XML à partir du contenu de la réponseserviceForModel(model) Renvoie le service LLM pour un modèle particulier.
LLM . serviceForModel ( "gpt-4-turbo-preview" ) ; // openai modelForService(service) Renvoie le LLM par défaut pour un service .
LLM . modelForService ( "openai" ) ; // gpt-4-turbo-preview
LLM . modelForService ( LLM . OPENAI ) ; // gpt-4-turbo-previewRéponse
LLM.js renvoie les résultats de llm.send() et llm.chat() , généralement le contenu de la chaîne du LLM complétant votre invite.
await LLM ( "hello" ) ; // "hi" Mais lorsque vous utilisez schema et tools , LLM.js renvoie généralement un objet JSON.
const tool = {
"name" : "generate_primary_colors" ,
"description" : "Generates the primary colors" ,
"parameters" : {
"type" : "object" ,
"properties" : {
"colors" : {
"type" : "array" ,
"items" : { "type" : "string" }
}
} ,
"required" : [ "colors" ]
}
} ;
await LLM ( "what are the 3 primary colors in physics?" ) ;
// { colors: ["red", "green", "blue"] }
await LLM ( "what are the 3 primary colors in painting?" ) ;
// { colors: ["red", "yellow", "blue"] } Et en passant {stream: true} dans options , LLM.js renverra un générateur et commencera à produire des résultats immédiatement.
const stream = await LLM ( "Once upon a time" , { stream : true } ) ;
for await ( const message of stream ) {
process . stdout . write ( message ) ;
} La réponse est basée sur ce que vous demandez au LLM de faire, et LLM.js essaie toujours de faire la bonne chose.
L'API Message History dans LLM.js est exactement la même que le format d'historique des messages OpenAI.
await LLM ( [
{ role : "user" , content : "remember the secret codeword is blue" } ,
{ role : "assistant" , content : "OK I will remember" } ,
{ role : "user" , content : "what is the secret codeword I just told you?" } ,
] ) ; // Response: bluePossibilités
role <string> : Qui dit le content ? user , system ou assistantcontent <string> : contenu du texte du message LLM.js fournit une commande llm utile pour votre shell. llm est un moyen pratique d'appeler des dizaines de LLM et d'accéder à toute la puissance de LLM.js sans programmation.
Accédez-y globalement en l'installant à partir de NPM
npm install @themaximalist/llm.js -g Ensuite, vous pouvez appeler la commande llm depuis n'importe où dans votre terminal.
> llm the color of the sky is
blueLes messages sont renvoyés en temps réel, donc tout est très rapide.
Vous pouvez également lancer un --chat pour mémoriser l'historique des messages et poursuivre votre conversation ( Ctrl-C pour quitter).
> llm remember the codeword is blue. say ok if you understand --chat
OK, I understand.
> what is the codeword ?
The codeword is blue.Ou changez facilement de LLM à la volée :
> llm the color of the sky is --model claude-v2
blue Voir l'aide avec llm --help
Usage: llm [options] [input]
Large Language Model library for OpenAI, Google, Anthropic, Mistral, Groq and LLaMa
Arguments:
input Input to send to LLM service
Options:
-V, --version output the version number
-m, --model < model > Completion Model (default: llamafile)
-s, --system < prompt > System prompt (default: " I am a friendly accurate English speaking chat bot " ) (default: " I am a friendly accurate English speaking chat bot " )
-t, --temperature < number > Model temperature (default 0.8) (default: 0.8)
-c, --chat Chat Mode
-h, --help display help for command LLM.js et llm utilisent le module debug npm avec l'espace de noms llm.js
Affichez les journaux de débogage en définissant la variable d'environnement DEBUG .
> DEBUG=llm.js * llm the color of the sky is
# debug logs
blue
> export DEBUG=llm.js *
> llm the color of the sky is
# debug logs
blue LLM.js propose de nombreux tests qui peuvent servir de guide pour voir comment il est utilisé.
L'utilisation des LLM en production peut s'avérer délicate en raison du suivi de l'historique, de la limitation du débit, de la gestion des clés API et de la manière de facturer.
Model Deployer est une API en face de LLM.js , qui gère tous ces détails et bien plus encore.
Son utilisation est simple, spécifiez modeldeployer comme service et votre clé API de Model Deployer comme model .
await LLM ( "hello world" , { service : "modeldeployer" , model : "api-key" } ) ;Vous pouvez également configurer des paramètres spécifiques et éventuellement en remplacer certains sur le client.
await LLM ( "the color of the sky is usually" , {
service : "modeldeployer" ,
model : "api-key" ,
endpoint : "https://example.com/api/v1/chat" ,
max_tokens : 1 ,
temperature : 0
} ) ; LLM.js peut être utilisé sans Model Deployer, mais si vous déployez des LLM en production, c'est un excellent moyen de les gérer.
LLM.js a fait l'objet d'un développement intensif tandis que les LLM évoluent rapidement. Nous avons commencé à nous installer sur une interface stable et documenterons les modifications ici.
v0.6.6 — Ajout de la prise en charge du navigateurv0.6.5 — Ajout de Llama 3 et ensemblev0.6.4 — Ajout de Groq et abort()v0.6.3 — Ajout d'analyseurs JSON/XML/Markdown et d'un gestionnaire de fluxv0.6.2 — Correction d'un bug avec le streaming Googlev0.6.1 — Correction d'un bug pour ne pas ajouter de réponses videsv0.6.0 — Ajout d'Anthropic Claude 3v0.5.9 — Ajout d'Ollamav0.5.4 — Ajout de Google Geminiv0.5.3 — Ajout de Mistralv0.5.0 — Création du site internetv0.4.7 — Outils OpenAI, flux JSONv0.3.5 — Ajout de ModelDeployerv0.3.2 — Ajout du fichier Llamafilev0.2.5 — Ajout d'Anthropic, CLIv0.2.4 — Options de discussionv0.2.2 — Interface unifiée LLM(), streamingv0.1.2 — Docs, invite systèmev0.0.1 — Création de LLM.js avec prise en charge d'OpenAI LLM.js est actuellement utilisé dans les projets suivants :
MIT
Créé par The Maximalist, consultez nos projets open source.
