parea sdk py

Testen, bewerten und überwachen Sie Ihre KI -Anwendung

? Twitter/X • ? Zwietracht • Parea ai • ? Dokumentation

Parea AI bietet eine SDK zur Bewertung und Überwachung Ihrer KI -Anwendungen. Unten finden Sie QuickStarts zu:

• Bewerten und testen Sie Ihre LLM -App
• Instrumentenprotokollierung und Beobachtbarkeit für Ihre LLM -App
• Bereitstellung von Eingabeaufforderungen, um die Zusammenarbeit zwischen Ingenieuren und Subjektexperten zu ermöglichen

Unsere vollständigen Dokumente sind hier.

Installation

pip install -U parea-ai

oder mit Poetry installieren

poetry add parea-ai

Bewertung Ihrer LLM -App

Das Testen Ihrer AI -App bedeutet, sie über einen Datensatz auszuführen und mit einer Bewertungsfunktion zu bewerten. Dies geschieht in Parea durch Definieren und Ausführen von Experimenten. Im Folgenden können Sie sehen, wie Sie einen Grußbot mit der Levenshtein -Distanzmetrik testen können.

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

Im Snippet oben haben wir den trace Decorator verwendet, um alle Eingänge und Ausgänge der Funktion zu erfassen. Dieser Dekorateur ermöglicht es auch, die Ausgabe zu erzielen, indem die levenshtein -Bewertung im Hintergrund ausgeführt wird. Dann haben wir ein Experiment über p.experiment definiert, um unsere Funktion ( greeting ) über einen Datensatz (hier eine Liste von Wörterbüchern) zu bewerten. Schließlich wird das Aufrufen des run das Experiment ausführen und einen Bericht über Ausgänge, Ergebnisse und Spuren für jede Probe des Datensatzes erstellen. Hier finden Sie einen Link zum ausgeführten Experiment. (TODO: Füllungsexperiment)

Weitere Ressourcen

Lesen Sie mehr über das Schreiben, Ausführen und Analysieren von Experimenten in unseren Dokumenten.

Protokollierung und Beobachtbarkeit

Durch das Einwickeln der jeweiligen Clients können Sie alle Ihre LLM -Anrufe automatisch auf Openai & Anthropic protokollieren. Darüber hinaus können Sie mit dem trace Decorator hierarchische Spuren Ihrer LLM -Anwendung für z. B. Associate LLM -Aufrufe mit dem Abrufschritt einer Rag -Pipeline erstellen. Hier sehen Sie die vollständige Beobachtbarkeitsdokumentation und unsere Integrationen in Langchain, Ausbilder, DSPY, Litellm & More.

Melden Sie sich automatisch alle Ihre OpenAI -Anrufe an

Um einen OpenAI -Anruf automatisch zu protokollieren, können Sie den OpenAI -Client mit der Methode wrap_openai_client mit dem Parea -Client einwickeln.

 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 )

Melden Sie sich automatisch alle Ihre anthropischen Anrufe an

Um einen anthropischen Anruf automatisch zu protokollieren, können Sie den anthropischen Client mit der Parea -Client mit der Methode wrap_anthropic_client mit dem Parea -Client einwickeln.

 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 )

Verschachtelte Spuren

Durch die Verwendung des trace Decorators können Sie hierarchische Spuren Ihrer LLM -Anwendung erstellen.

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

Eingabeaufforderungen

Implementierte Eingabeaufforderungen ermöglichen die Zusammenarbeit mit Nicht-Engineer wie Produktmanagern und Subjektexperten. Benutzer können Eingabeaufforderungen auf dem Spielplatz von Parea iterieren, verfeinern und testen. Nach dem Basteln können Sie diese Eingabeaufforderung bereitstellen, was bedeutet, dass sie über einen API -Endpunkt ausgesetzt ist, um sie in Ihre Anwendung zu integrieren. Checkout in unseren vollständigen Dokumenten hier.

 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 )

? Lizenz

Dieses Projekt ist gemäß den Bestimmungen der Apache Software License 2.0 -Lizenz lizenziert. Weitere Informationen finden Sie unter Lizenz.

? Zitat

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