Monitoring Quickstart

Start Logging

Use any of the code snippets below to start logging your LLM requests.

Python
Typescript
Curl

Parea supports automatic logging for OpenAI, Anthropic, Langchain, or any model if using Parea’s completion method.The @trace decorator allows you to associate multiple functions into a single trace.

from openai import OpenAI
from parea import Parea

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)  # if OpenAI python version < 1.0.0: p.wrap_openai_client(openai)

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

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)

from parea import Parea
from parea.schemas import LLMInputs, Message, ModelParams, Role, Completion

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

response = p.completion(
    Completion(llm_configuration=LLMInputs(
        model="gpt-3.5-turbo",  # this can be any model enabled on Parea
        model_params=ModelParams(temp=0.5),
        messages=[Message(
            role=Role.user,
            content="Write a Hello World program in Python using FastAPI.",
        )],
    ))
)
print(response.content)

from parea import Parea, trace
from parea.schemas import LLMInputs, Message, ModelParams, Completion

p = Parea(api_key="PAREA_API_KEY")

def llm(messages: list[dict[str, str]]):
    return p.completion(
        Completion(
            llm_configuration=LLMInputs(
                model="gpt-3.5-turbo",
                model_params=ModelParams(temp=0.5),
                messages=[Message(**m) for m in messages],
            )
        )
    ).content

def hello_world(lang: str, framework: str):
    return llm([{"role": "user", "content": f"Write a Hello World program in {lang} using {framework}."}])

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

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

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from parea import Parea
from parea.utils.trace_integrations.langchain import PareaAILangchainTracer

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

llm = ChatOpenAI(openai_api_key="OPENAI_API_KEY")  # replace with your API key
prompt = ChatPromptTemplate.from_messages([("user", "{input}")])
chain = prompt | llm | StrOutputParser()

response = chain.invoke(
    {"input": "Write a Hello World program in Python using FastAPI."},
    config={"callbacks": [handler]},
)
print(response)

Parea supports automatic logging for OpenAI or any model using Parea’s completion method. Support for Anthropic’s Claude is coming soon (reach out for early access).The trace() wrapper allows you to associate multiple functions into a single trace.

import OpenAI from 'openai';
import {Parea, patchOpenAI} from "parea-ai";

new Parea("PAREA_API_KEY"); // still needed for tracing, replace with your API key
const openai = new OpenAI();
patchOpenAI(openai);

async function main(): Promise<string | null> {
    const response = await openai.chat.completions.create({
        messages: [{role: 'user', content: "Write a hello world program in Python using FastAPI."}],
        model: 'gpt-3.5-turbo',
    })
    return response.choices[0].message.content;
}

import {Parea} from "parea-ai";

const p = new Parea("PAREA_API_KEY"); // replace with your API key

async function main(): Promise<string | null> {
    const response = await p.completion({
        llm_configuration: {
            model: 'gpt-3.5-turbo',
            model_params: {temp: 0.5},
            messages: [{role: 'user', content: "Write a hello world program in Python using FastAPI."}],
        }
    });
    return response.content
}

import {CompletionResponse, Message, Parea, trace} from "parea-ai";

const p = new Parea("PAREA_API_KEY") // replace with your API key

async function llm(messages: Message[]): Promise<string | null> {
    const response: CompletionResponse = await p.completion({
        llm_configuration: {
            model: 'gpt-3.5-turbo',
            model_params: {temp: 0.5},
            messages: messages,
        },
    });
    return response.content
}

async function helloWorld(lang: string, framework: string): Promise<string | null> {
    return llm([{role: 'user', content: `Write a hello world ${lang} in python using ${framework}.`}])
}

async function critiqueCode(code: string | null): Promise<string | null> {
    return llm([{role: 'user', content: `How can we improve this code: \n ${code}`}])
}

const chain = trace(
    'Chain', async (lang: string, framework: string): Promise<string | null> => {
        return await critiqueCode(await helloWorld(lang, framework));
    },
);

async function main(): Promise<string | null> {
    return await chain('Python', 'FastAPI')
}

Replace $PAREA_API_KEY with your API key.

curl 'https://parea-ai-backend-us-9ac16cdbc7a7b006.onporter.run/api/parea/v1/completion' \
-H 'Content-Type: application/json' \
-H 'x-api-key: $PAREA_API_KEY' \
-d '{
    "llm_configuration": {
        "model": "gpt-3.5-turbo",
        "model_params": {"temp": 0.5},
        "messages": [
            {
                "role": "user",
                "content": "Write a hello world program in Python using FastAPI."
            }
        ]
    }
}'

​What’s Next?

What’s Next?