unify

Unifier

Nous sommes en mission pour simplifier le paysage LLM, Unify vous permet:

• ? Utilisez n'importe quel LLM de n'importe quel fournisseur : avec une seule interface, vous pouvez utiliser tous les LLM de tous les fournisseurs en modifiant simplement une chaîne. Pas besoin de gérer plusieurs touches API ou de gérer différents formats d'entrée-sortie. Unify gère tout cela pour vous!

• Améliorez les performances de LLM : ajoutez vos propres tests et évals personnalisés et comparez vos propres invites sur tous les modèles et fournisseurs. Comparaison de la qualité, du coût et de la vitesse, et itérez sur votre invite système jusqu'à ce que tous les cas de test passent, et vous pouvez déployer votre application!

• ? Route vers le meilleur LLM : Améliorez la qualité, le coût et la vitesse en acheminant le modèle et le fournisseur parfait pour chaque invite individuelle.

Start

Installez simplement le package:

pip install unifyai

Ensuite, inscrivez-vous pour obtenir votre clé API, puis vous êtes prêt à partir!

 import unify
client = unify . Unify ( "gpt-4o@openai" , api_key = < your_key > )
client . generate ( "hello world!" )

Note

Nous vous recommandons d'utiliser Python-Dotenv pour ajouter UNIFY_KEY="My API Key" à votre fichier .env , en évitant la nécessité d'utiliser l'argument api_key comme ci-dessus. Pour le reste de la lecture, nous supposerons que vous définissez votre clé en tant que variable d'environnement.

Modèles de listing, fournisseurs et points de terminaison

Vous pouvez répertorier tous les modèles, fournisseurs et points de terminaison ( <model>@<provider> paire) comme suit:

 models = unify . list_models ()
providers = unify . list_providers ()
endpoints = unify . list_endpoints ()

Vous pouvez également filtrer dans ces fonctions comme suit:

 import random
anthropic_models = unify . list_models ( "anthropic" )
client . set_endpoint ( random . choice ( anthropic_models ) + "@anthropic" )

latest_llama3p1_providers = unify . list_providers ( "llama-3.1-405b-chat" )
client . set_endpoint ( "llama-3.1-405b-chat@" + random . choice ( latest_llama3p1_providers ))

openai_endpoints = unify . list_endpoints ( "openai" )
client . set_endpoint ( random . choice ( openai_endpoints ))

mixtral8x7b_endpoints = unify . list_endpoints ( "mixtral-8x7b-instruct-v0.1" )
client . set_endpoint ( random . choice ( mixtral8x7b_endpoints ))

Modification des modèles, fournisseurs et points de terminaison

Si vous souhaitez modifier le endpoint , model ou le provider , vous pouvez le faire en utilisant les méthodes .set_endpoint , .set_model , .set_provider respectivement.

 client . set_endpoint ( "mistral-7b-instruct-v0.3@deepinfra" )
client . set_model ( "mistral-7b-instruct-v0.3" )
client . set_provider ( "deepinfra" )

Invitation personnalisée

Vous pouvez influencer le personnage du modèle à l'aide de l'argument system_message dans la fonction .generate :

 response = client . generate (
    user_message = "Hello Llama! Who was Isaac Newton?" ,  system_message = "You should always talk in rhymes"
)

Si vous souhaitez envoyer plusieurs messages à l'aide de la fonction .generate , vous devez utiliser l'argument messages comme suit:

 messages = [
   { "role" : "user" , "content" : "Who won the world series in 2020?" },
   { "role" : "assistant" , "content" : "The Los Angeles Dodgers won the World Series in 2020." },
   { "role" : "user" , "content" : "Where was it played?" }
]
res = client . generate ( messages = messages )

Arguments par défaut

Lorsque vous interrogez LLMS, vous voulez souvent garder de nombreux aspects de votre invite fixés et ne modifier qu'un petit sous-ensemble de l'invite sur chaque appel ultérieur.

Par exemple, vous souhaiterez peut-être réparer le tempéré, l'invite du système et les outils disponibles, tout en transmettant différents messages utilisateur provenant d'une application en aval. Tous les clients d'Unify rendent cela très simple via des arguments par défaut, qui peuvent être spécifiés dans le constructeur, et peuvent également être définis à tout moment à l'aide de méthodes de setters.

Par exemple, le code suivant passera temperature=0.5 à toutes les demandes suivantes, sans avoir besoin d'être transmise à plusieurs reprises dans la méthode .generate() .

 client = unify . Unify ( "claude-3-haiku@anthropic" , temperature = 0.5 )
client . generate ( "Hello world!" )
client . generate ( "What a nice day." )

Tous les paramètres peuvent également être récupérés par Getters et définis via les setters:

 client = unify . Unify ( "claude-3-haiku@anthropic" , temperature = 0.5 )
print ( client . temperature )  # 0.5
client . set_temperature ( 1.0 )
print ( client . temperature )  # 1.0

Le passage d'une valeur à la méthode .generate() écrasera la valeur par défaut spécifiée pour le client.

 client = unify . Unify ( "claude-3-haiku@anthropic" , temperature = 0.5 )
client . generate ( "Hello world!" ) # temperature of 0.5
client . generate ( "What a nice day." , temperature = 1.0 ) # temperature of 1.0 

Utilisation asynchrone

Pour des performances optimales dans la gestion de plusieurs demandes utilisateur simultanément, comme dans une application Chatbot, le traitement de leur traitement de manière asynchrone est recommandé. Un exemple minimal utilisant AsyncUnify est donné ci-dessous:

 import unify
import asyncio
async_client = unify . AsyncUnify ( "llama-3-8b-chat@fireworks-ai" )
asyncio . run ( async_client . generate ( "Hello Llama! Who was Isaac Newton?" ))

Plus un exemple plus appliqué, le traitement de plusieurs demandes en parallèle peut ensuite être fait comme suit:

 import unify
import asyncio
clients = dict ()
clients [ "gpt-4o@openai" ] = unify . AsyncUnify ( "gpt-4o@openai" )
clients [ "claude-3-opus@anthropic" ] = unify . AsyncUnify ( "claude-3-opus@anthropic" )
clients [ "llama-3-8b-chat@fireworks-ai" ] = unify . AsyncUnify ( "llama-3-8b-chat@fireworks-ai" )


async def generate_responses ( user_message : str ):
   responses_ = dict ()
   for endpoint_ , client in clients . items ():
       responses_ [ endpoint_ ] = await client . generate ( user_message )
   return responses_

responses = asyncio . run ( generate_responses ( "Hello, how's it going?" ))
for endpoint , response in responses . items ():
   print ( "endpoint: {}" . format ( endpoint ))
   print ( "response: {} n " . format ( response ))

En ce qui concerne la fonctionnalité, les clients asynchrones et synchrones sont identiques.

Réponses en streaming

Vous pouvez activer les réponses en streaming en définissant stream=True dans la fonction .generate .

 import unify
client = unify . Unify ( "llama-3-8b-chat@fireworks-ai" )
stream = client . generate ( "Hello Llama! Who was Isaac Newton?" , stream = True )
for chunk in stream :
    print ( chunk , end = "" )

Il fonctionne exactement de la même manière avec les clients asynchrones.

 import unify
import asyncio
async_client = unify . AsyncUnify ( "llama-3-8b-chat@fireworks-ai" )

async def stream ():
   async_stream = await async_client . generate ( "Hello Llama! Who was Isaac Newton?" , stream = True )
   async for chunk in async_stream :
       print ( chunk , end = "" )

asyncio . run ( stream ())

Plonger plus profondément

Pour en savoir plus sur nos fonctionnalités API plus avancées, nos benchmarking et notre routage LLM, allez voir nos documents complets!