unify

Unificar

Estamos em uma missão para simplificar o cenário do LLM, o Unify permite:

• ? Use qualquer LLM de qualquer provedor : com uma única interface, você pode usar todos os LLMs de todos os provedores simplesmente alterando uma string. Não há necessidade de gerenciar várias teclas da API ou lidar com diferentes formatos de entrada e saída. Unificar lida com tudo isso para você!

• Melhore o desempenho do LLM : adicione seus próprios testes e evalas personalizados e compare seus próprios prompts em todos os modelos e provedores. Comparando a qualidade, o custo e a velocidade e iterar no seu sistema de sistema até que todos os casos de teste sejam aprovados e você pode implantar seu aplicativo!

• ? Rota para o melhor LLM : melhore a qualidade, o custo e a velocidade, roteando o modelo e o provedor perfeito para cada prompt individual.

Investir rápido

Basta instalar o pacote:

pip install unifyai

Em seguida, inscreva -se para obter sua chave da API, então você está pronto para ir!

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

Observação

Recomendamos o uso do python-dotenv para adicionar UNIFY_KEY="My API Key" ao seu arquivo .env , evitando a necessidade de usar o argumento api_key como acima. Para o restante do ReadMe, assumiremos que você defina sua chave como uma variável de ambiente.

Modelos de listagem, provedores e terminais

Você pode listar todos os modelos, provedores e pontos de extremidade ( <model>@<provider> par) da seguinte forma:

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

Você também pode filtrar nessas funções da seguinte maneira:

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

Modelos, provedores e terminais

Se você deseja alterar o endpoint , model ou o provider , pode fazê -lo usando os 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" )

Solicitação personalizada

Você pode influenciar a persona do modelo usando o argumento system_message na função .generate :

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

Se você deseja enviar várias mensagens usando a função .generate , você deve usar o argumento messages da seguinte forma:

 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 padrão

Ao consultar o LLMS, você geralmente deseja manter muitos aspectos do seu prompt fixo e alterar apenas um pequeno subconjunto do prompt em cada chamada subsequente.

Por exemplo, você pode querer corrigir o temperado, o prompt do sistema e as ferramentas disponíveis, enquanto passam mensagens de usuário diferentes provenientes de um aplicativo a jusante. Todos os clientes da Unify tornam isso muito simples por meio de argumentos padrão, que podem ser especificados no construtor e também podem ser definidos a qualquer momento usando métodos de setters.

Por exemplo, o código a seguir passará temperature=0.5 para todas as solicitações subsequentes, sem precisar ser transmitidas repetidamente para o método .generate() .

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

Todos os parâmetros também podem ser recuperados pelos getters e definidos por meio 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

A passagem de um valor para o método .generate() substituirá o valor padrão especificado para o 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 assíncrono

Para um desempenho ideal para lidar com várias solicitações de usuário simultaneamente, como em um aplicativo Chatbot, recomenda -se processá -los de maneira assíncrona. Um exemplo mínimo usando AsyncUnify é dado abaixo:

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

Mais um exemplo mais aplicado, o processamento de várias solicitações em paralelo pode ser feito da seguinte maneira:

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

Em termos de funcionalidade, os clientes assíncronos e síncronos são idênticos.

Respostas de streaming

Você pode ativar respostas de streaming definindo stream=True na função .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 exatamente da mesma maneira com os clientes da 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 ())

Mergulhe mais fundo

Para saber mais sobre nossos recursos de API mais avançados, benchmarking e roteamento de LLM, confira nossos documentos abrangentes!