parea sdk py
v0.2.215
Pruebe, evalúe y monitoree su aplicación de IA
? Twitter/x • ? Discordia • PAREA AI • ? Documentación
PAREA AI proporciona un SDK para evaluar y monitorear sus aplicaciones de IA. A continuación puede ver rápidos a:
Nuestros documentos completos están aquí.
pip install -U parea-ai o instalar con Poetry
poetry add parea-aiProbar su aplicación AI significa ejecutarlo a través de un conjunto de datos y calificarlo con una función de evaluación. Esto se hace en PAREA definiendo y ejecutando experimentos. A continuación, puede ver el ejemplo de cómo probar un bot con la métrica de distancia 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 () En el fragmento de arriba, utilizamos el decorador trace para capturar cualquier entrada y salida de la función. Este decorador también permite obtener la salida al ejecutar la evaluación levenshtein en el fondo. Luego, definimos un experimento a través de p.experiment para evaluar nuestra función ( greeting ) en un conjunto de datos (aquí una lista de diccionarios). Finalmente, Calling run ejecutará el experimento y creará un informe de salidas, puntajes y trazas para cualquier muestra del conjunto de datos. Puede encontrar un enlace al experimento ejecutado aquí. (TODO: Experimento de llenado)
Lea más sobre cómo escribir, ejecutar y analizar experimentos en nuestros documentos.
Al envolver a los clientes respectivos, puede registrar automáticamente todas sus llamadas de LLM a OpenAI y Anthrope. Además, utilizando el decorador trace puede crear rastros jerárquicos de su aplicación LLM a las llamadas de LLM Associate LLM con el paso de recuperación de una tubería RAG. Puede ver la documentación de observabilidad completa aquí y nuestras integraciones en Langchain, Instructor, DSPY, Litellm y más aquí.
Para registrar automáticamente cualquier llamada OpenAI, puede envolver el cliente OpenAI con el cliente PAREA usando el 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 ) Para registrar automáticamente cualquier llamada antrópica, puede envolver el cliente antrópico con el cliente PAREA utilizando el 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 ) Al usar el Decorador trace , puede crear rastros jerárquicos de su aplicación 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" ))Las indicaciones implementadas permiten la colaboración con no ingenieros, como gerentes de productos y expertos en materia. Los usuarios pueden iterar, refinar y probar las indicaciones en el patio de recreo de Parea. Después de jugar, puede implementar ese aviso, lo que significa que está expuesto a través de un punto final API para integrarlo en su aplicación. Consulte nuestros documentos completos aquí.
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 ) Este proyecto tiene licencia bajo los términos de la licencia Apache Software License 2.0 . Vea la licencia para más detalles.
@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} }
}
