unify

Unificar

Estamos en una misión para simplificar el paisaje de LLM, unify le permite:

• ? Use cualquier LLM de cualquier proveedor : con una sola interfaz, puede usar todos los LLM de todos los proveedores simplemente cambiando una cadena. No es necesario administrar varias teclas API o manejar diferentes formatos de entrada-salida. ¡Unify maneja todo eso por ti!

• Mejore el rendimiento de LLM : agregue sus propias pruebas y evals personalizadas, y compare sus propias indicaciones en todos los modelos y proveedores. Comparando la calidad, el costo y la velocidad, e iterar en su solicitud de sistema hasta que todos los casos de prueba pasen, ¡y puede implementar su aplicación!

• ? Ruta a la mejor LLM : Mejore la calidad, el costo y la velocidad mediante el enrutamiento al modelo y el proveedor perfecto para cada mensaje individual.

Inicio rápido

Simplemente instale el paquete:

pip install unifyai

Luego regístrese para obtener su clave API, ¡entonces estará listo para comenzar!

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

Nota

Recomendamos usar Python-Dotenv para agregar UNIFY_KEY="My API Key" a su archivo .env , evitando la necesidad de usar el argumento api_key como se indicó anteriormente. Para el resto del ReadMe, asumiremos que establece su clave como una variable de entorno.

Modelos de listado, proveedores y puntos finales

Puede enumerar todos los modelos, proveedores y puntos finales ( <model>@<provider> par) de la siguiente manera:

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

También puede filtrar dentro de estas funciones de la siguiente manera:

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

Cambiando modelos, proveedores y puntos finales

Si desea cambiar el endpoint , model o el provider , puede hacerlo utilizando los métodos .set_endpoint , .set_model , .set_provider respectivamente.

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

Solicitación personalizada

Puede influir en la persona del modelo utilizando el argumento system_message en la función .generate :

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

Si desea enviar múltiples mensajes utilizando la función .generate , debe usar el argumento messages de la siguiente manera:

 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 )

Argumentos predeterminados

Al consultar LLMS, a menudo desea mantener muchos aspectos de su aviso fijos, y solo cambiar un pequeño subconjunto de la solicitud en cada llamada posterior.

Por ejemplo, es posible que desee solucionar el Temperate, la solicitud del sistema y las herramientas disponibles, al tiempo que pasa diferentes mensajes de usuario que provienen de una aplicación posterior. Todos los clientes en Unify lo hacen muy simple a través de argumentos predeterminados, que se pueden especificar en el constructor, y también se pueden establecer en cualquier momento utilizando métodos Setters.

Por ejemplo, el siguiente código pasará temperature=0.5 a todas las solicitudes posteriores, sin necesidad de pasar repetidamente al método .generate() .

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

Getters también puede recuperar todos los parámetros y establecer a través de 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

Pasar un valor al método .generate() sobrescribirá el valor predeterminado especificado para el cliente.

 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 

Uso asincrónico

Para un rendimiento óptimo en el manejo de múltiples solicitudes de usuarios simultáneamente, como en una aplicación de chatbot, se recomienda procesarlas de manera asincrónica. A continuación se da un ejemplo mínimo usando AsyncUnify :

 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?" ))

Más un ejemplo más aplicado, el procesamiento de múltiples solicitudes en paralelo se puede realizar de lo siguiente:

 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 cuanto a la funcionalidad, los clientes asincrónicos y sincrónicos son idénticos.

Respuestas de transmisión

Puede habilitar las respuestas de transmisión estableciendo stream=True en la función .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 = "" )

Funciona exactamente de la misma manera con los clientes de Async.

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

Sumergirse

Para obtener más información sobre nuestras características de la API más avanzadas, la evaluación comparativa y el enrutamiento de LLM, ¡visite nuestros documentos completos!