parea sdk py

Tester, évaluer et surveiller votre application AI

? Twitter / x • ? Discorde • Parea ai • ? Documentation

Parea AI fournit un SDK pour évaluer et surveiller vos applications d'IA. Ci-dessous, vous pouvez voir Quickstarts pour:

• Évaluez et testez votre application LLM
• Enregistrement et observabilité des instruments pour votre application LLM
• Déploiement d'invites pour permettre la collaboration entre les ingénieurs et les experts en matière

Nos documents complets sont là.

Installation

pip install -U parea-ai

ou installer avec Poetry

poetry add parea-ai

Évaluation de votre application LLM

Tester votre application AI signifie l'exécuter sur un ensemble de données et le marquer avec une fonction d'évaluation. Cela se fait dans Parea en définissant et en exécutant des expériences. Ci-dessous, vous pouvez voir peut-être l'exemple de la façon de tester un bot de salutation avec la métrique de distance 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 ()

Dans l'extrait ci-dessus, nous avons utilisé le décorateur trace pour capturer les entrées et sorties de la fonction. Ce décorateur permet également de marquer la sortie en exécutant l'évaluation de levenshtein en arrière-plan. Ensuite, nous avons défini une expérience via p.experiment pour évaluer notre fonction ( greeting ) sur un ensemble de données (ici une liste de dictionnaires). Enfin, l'appel run exécutera l'expérience et créera un rapport de sorties, scores et traces pour tout échantillon de l'ensemble de données. Vous pouvez trouver un lien vers l'expérience exécutée ici. (TODO: expérience de remplissage)

Plus de ressources

En savoir plus sur la façon d'écrire, d'exécuter et d'analyser les expériences dans nos documents.

Journalisation et observabilité

En emballant les clients respectifs, vous pouvez enregistrer automatiquement tous vos appels LLM à Openai & Anthropic. De plus, en utilisant le décorateur trace , vous pouvez créer des traces hiérarchiques de votre application LLM à des appels LLM Associate LLM à l'étape de récupération d'un pipeline de chiffons. Vous pouvez voir la documentation complète d'observabilité ici et nos intégrations dans Langchain, instructeur, DSPY, Litellm et plus ici.

Enregistrez automatiquement tous vos appels ouverts

Pour enregistrer automatiquement n'importe quel appel OpenAI, vous pouvez envelopper le client OpenAI avec le client Parea à l'aide de la méthode 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 )

Enregistrez automatiquement tous vos appels anthropes

Pour enregistrer automatiquement n'importe quel appel anthropique, vous pouvez envelopper le client anthropique avec le client Parea à l'aide de la méthode 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 )

Traces imbriquées

En utilisant le décorateur trace , vous pouvez créer des traces hiérarchiques de votre application 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" ))

Déploiement d'invites

Les invites déployées permettent une collaboration avec des non-ingénieurs tels que les chefs de produit et les experts en matière de matière. Les utilisateurs peuvent itérer, affiner et tester les invites sur l'aire de jeux de Parea. Après le bricolage, vous pouvez déployer cette invite, ce qui signifie qu'il est exposé via un point de terminaison de l'API pour l'intégrer dans votre application. Découvrez nos documents complets ici.

 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 )

? Licence

Ce projet est concédé sous licence de la Apache Software License 2.0 . Voir la licence pour plus de détails.

? Citation

 @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} }
}