parea sdk py

Teste, avalie e monitore seu aplicativo de IA

? Twitter/x • ? Discord • parea ai • ? Documentação

O Parea AI fornece um SDK para avaliar e monitorar seus aplicativos de IA. Abaixo você pode ver o QuickStarts para:

• Avalie e teste seu aplicativo LLM
• Registro de instrumentos e observabilidade para o seu aplicativo LLM
• Implantando avisos para permitir a colaboração entre engenheiros e especialistas em assuntos

Nossos documentos completos estão aqui.

Instalação

pip install -U parea-ai

ou instalar com Poetry

poetry add parea-ai

Avaliando seu aplicativo LLM

Testar seu aplicativo AI significa executá -lo em um conjunto de dados e pontuá -lo com uma função de avaliação. Isso é feito em Parea, definindo e executando experimentos. Abaixo, você pode ver pode um exemplo de como testar um bot de saudação com a métrica de distância de Levenshtein.

 from parea import Parea , trace
from parea . evals . general import levenshtein

p = Parea ( api_key = "<<PAREA_API_KEY>>" )  # replace with Parea AI API key

# use the trace decorator to score the output with the Levenshtein distance  
@ trace ( eval_funcs = [ levenshtein ])
def greeting ( name : str ) -> str :
    return f"Hello { name } "

data = [
    { "name" : "Foo" , "target" : "Hi Foo" },
    { "name" : "Bar" , "target" : "Hello Bar" },
]

p . experiment (
    name = "Greeting" ,
    data = data ,
    func = greeting ,
). run ()

No trecho acima, usamos o decorador trace para capturar quaisquer entradas e saídas da função. Este decorador também permite pontuar a saída executando o levenshtein Eval em segundo plano. Em seguida, definimos um experimento via p.experiment para avaliar nossa função ( greeting ) sobre um conjunto de dados (aqui uma lista de dicionários). Finalmente, a run de chamada executará o experimento e criará um relatório de saídas, pontuações e traços para qualquer amostra do conjunto de dados. Você pode encontrar um link para o experimento executado aqui. (TODO: Experiência de preencher)

Mais recursos

Leia mais sobre como escrever, executar e analisar experimentos em nossos documentos.

Registro e observabilidade

Ao envolver os respectivos clientes, você pode registrar automaticamente todas as suas chamadas LLM para o OpenAI e Antrópico. Além disso, usando o decorador trace , você pode criar traços hierárquicos do seu aplicativo LLM para o EG Associate LLM Chamadas com a etapa de recuperação de um pipeline RAG. Você pode ver a documentação completa de observabilidade aqui e nossas integrações em Langchain, Instrutor, DSPY, Litellm e muito mais aqui.

Registre automaticamente todas as suas chamadas de abertura

Para registrar automaticamente qualquer chamada do OpenAI, você pode envolver o cliente OpenAI com o cliente PAREA usando o método wrap_openai_client .

 from openai import OpenAI
from parea import Parea

client = OpenAI ( api_key = "OPENAI_API_KEY" )

# All you need to do is add these two lines
p = Parea ( api_key = "PAREA_API_KEY" )  # replace with your API key
p . wrap_openai_client ( client )

response = client . chat . completions . create (
    model = "gpt-4o" ,
    messages = [
        {
            "role" : "user" ,
            "content" : "Write a Hello World program in Python using FastAPI." ,
        }
    ],
)
print ( response . choices [ 0 ]. message . content )

Registre automaticamente todas as suas chamadas antrópicas

Para registrar automaticamente qualquer chamada antrópica, você pode embrulhar o cliente antropia com o cliente Parea usando o método wrap_anthropic_client .

 import anthropic
from parea import Parea

p = Parea ( api_key = "PAREA_API_KEY" )  # replace with your API key

client = anthropic . Anthropic ()
p . wrap_anthropic_client ( client )

message = client . messages . create (
    model = "claude-3-opus-20240229" ,
    max_tokens = 1024 ,
    messages = [
        {
            "role" : "user" ,
            "content" : "Write a Hello World program in Python using FastAPI." ,
        }
    ],
)
print ( message . content [ 0 ]. text )

Traços aninhados

Usando o decorador trace , você pode criar traços hierárquicos do seu aplicativo LLM.

 from openai import OpenAI
from parea import Parea , trace

client = OpenAI ( api_key = "OPENAI_API_KEY" )  # replace with your API key

p = Parea ( api_key = "PAREA_API_KEY" )  # replace with your API key
p . wrap_openai_client ( client )


# We generally recommend creating a helper function to make LLM API calls.
def llm ( messages : list [ dict [ str , str ]]) -> str :
    response = client . chat . completions . create ( model = "gpt-4o" , messages = messages )
    return response . choices [ 0 ]. message . content


# This will give the Span the name of the function.
# Without the decorator the default name for all LLM call logs is `llm-openai`
@ trace
def hello_world ( lang : str , framework : str ):
    return llm ([{ "role" : "user" , "content" : f"Write a Hello World program in { lang } using { framework } ." }])

@ trace
def critique_code ( code : str ):
    return llm ([{ "role" : "user" , "content" : f"How can we improve this code: n { code } " }])

# Our top level function is called chain. By adding the trace decorator here,
# all sub-functions will automatically be logged and associated with this trace.
# Notice, you can also add metadata to the trace, we'll revisit this functionality later.
@ trace ( metadata = { "purpose" : "example" }, end_user_identifier = "John Doe" )
def chain ( lang : str , framework : str ) -> str :
    return critique_code ( hello_world ( lang , framework ))


print ( chain ( "Python" , "FastAPI" ))

Implantando prompts

Os avisos implantados permitem a colaboração com não-engenheiros, como gerentes de produto e especialistas em assuntos. Os usuários podem iterar, refinar e testar os avisos no playground da Parea. Após a mexer, você pode implantar esse prompt, o que significa que ele é exposto por meio de um endpoint da API para integrá -lo ao seu aplicativo. Confira nossos documentos completos aqui.

 from parea import Parea
from parea . schemas . models import Completion , UseDeployedPrompt , CompletionResponse , UseDeployedPromptResponse


p = Parea ( api_key = "<PAREA_API_KEY>" )

# You will find this deployment_id in the Parea dashboard
deployment_id = '<DEPLOYMENT_ID>'

# Assuming your deployed prompt's message is:
# {"role": "user", "content": "Write a hello world program using {{x}} and the {{y}} framework."}
inputs = { "x" : "Golang" , "y" : "Fiber" }

# You can easily unpack a dictionary into an attrs class
test_completion = Completion (
  ** {
    "deployment_id" : deployment_id ,
    "llm_inputs" : inputs ,
    "metadata" : { "purpose" : "testing" }
  }
)

# By passing in my inputs, in addition to the raw message with unfilled variables {{x}} and {{y}}, 
# you we will also get the filled-in prompt:
# {"role": "user", "content": "Write a hello world program using Golang and the Fiber framework."}
test_get_prompt = UseDeployedPrompt ( deployment_id = deployment_id , llm_inputs = inputs )


def main ():
  completion_response : CompletionResponse = p . completion ( data = test_completion )
  print ( completion_response )
  deployed_prompt : UseDeployedPromptResponse = p . get_prompt ( data = test_get_prompt )
  print ( " n n " )
  print ( deployed_prompt )

? Licença

Este projeto está licenciado nos termos da licença Apache Software License 2.0 . Consulte a licença para obter mais detalhes.

? Citação

 @misc { parea-sdk ,
  author = { joel-parea-ai,joschkabraun } ,
  title = { Parea python sdk } ,
  year = { 2023 } ,
  publisher = { GitHub } ,
  journal = { GitHub repository } ,
  howpublished = { url{https://github.com/parea-ai/parea-sdk} }
}