parea sdk py

Menguji, mengevaluasi & memantau aplikasi AI Anda

? Twitter/X • ? Perselisihan • Parea Ai • ? Dokumentasi

Parea AI menyediakan SDK untuk mengevaluasi & memantau aplikasi AI Anda. Di bawah ini Anda dapat melihat QuickStarts ke:

• Evaluasi & Uji Aplikasi LLM Anda
• Logging Instrumen & Pengamatan untuk Aplikasi LLM Anda
• Menyebarkan petunjuk untuk memungkinkan kolaborasi antara insinyur & ahli subjek

Dokumen lengkap kami ada di sini.

Instalasi

pip install -U parea-ai

Atau instal dengan Poetry

poetry add parea-ai

Mengevaluasi Aplikasi LLM Anda

Menguji aplikasi AI Anda berarti menjalankannya melalui dataset dan mencetaknya dengan fungsi evaluasi. Ini dilakukan di Parea dengan mendefinisikan & menjalankan eksperimen. Di bawah ini Anda dapat melihat Contoh Cara Menguji Bot Salam dengan Metrik Jarak 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 ()

Di cuplikan di atas, kami menggunakan dekorator trace untuk menangkap input & output fungsi apa pun. Dekorator ini juga memungkinkan untuk mencetak output dengan mengeksekusi eval levenshtein di latar belakang. Kemudian, kami mendefinisikan percobaan melalui p.experiment untuk mengevaluasi fungsi kami ( greeting ) melalui dataset (di sini daftar kamus). Akhirnya, Calling run akan menjalankan percobaan, dan membuat laporan output, skor & jejak untuk setiap sampel dataset. Anda dapat menemukan tautan ke eksperimen yang dieksekusi di sini. (Todo: Eksperimen Isi)

Lebih banyak sumber daya

Baca lebih lanjut tentang cara menulis, menjalankan & menganalisis eksperimen di dokumen kami.

Logging & Observability

Dengan membungkus klien masing -masing, Anda dapat secara otomatis mencatat semua panggilan LLM Anda ke Openai & Anthropic. Selain itu, menggunakan dekorator trace Anda dapat membuat jejak hierarkis dari aplikasi LLM Anda untuk EG Associate LLM Calls dengan langkah pengambilan pipa kain. Anda dapat melihat dokumentasi observabilitas penuh di sini dan integrasi kami ke Langchain, Instruktur, DSPY, Litellm & lainnya di sini.

Secara otomatis mencatat semua panggilan openai Anda

Untuk secara otomatis mencatat panggilan OpenAI, Anda dapat membungkus klien OpenAi dengan klien Parea menggunakan metode 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 )

Secara otomatis mencatat semua panggilan antropik Anda

Untuk secara otomatis mencatat panggilan antropik apa pun, Anda dapat membungkus klien antropik dengan klien parea menggunakan metode 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 )

Jejak bersarang

Dengan menggunakan trace Decorator, Anda dapat membuat jejak hierarkis dari aplikasi LLM Anda.

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

Menyebarkan petunjuk

Ditandingi yang digunakan memungkinkan kolaborasi dengan non-rekayasa seperti manajer produk & pakar subjek-materi. Pengguna dapat mengulangi, memperbaiki & menguji petunjuk di taman bermain Parea. Setelah mengutak -atik, Anda dapat menggunakan prompt itu yang berarti diekspos melalui titik akhir API untuk mengintegrasikannya ke dalam aplikasi Anda. Lihat dokumen lengkap kami di sini.

 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 )

? Lisensi

Proyek ini dilisensikan berdasarkan ketentuan lisensi Apache Software License 2.0 . Lihat lisensi untuk detail lebih lanjut.

? Kutipan

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