prismbrain 0.1.5

AI-native error tracking and observability for Python applications

prismbrain

AI-native error tracking and observability for Python applications. Captures errors, LLM calls, and application traces with AI-powered fix suggestions.

Installation

pip install prismbrain

Quick Start

import os
import prismbrain

gb = prismbrain.PrismBrain(api_key="gb_your_key")

# Capture errors
try:
    risky_operation()
except Exception as e:
    gb.capture_error(e, metadata={"user_id": "123"})

# Capture warnings and info
gb.capture_warning("Disk usage above 90%")
gb.capture_info("Deployment completed", metadata={"version": "1.2.0"})

# Get AI fix suggestions for a trace
suggestions = gb.get_suggestions(
    trace_id="...",
    provider_keys={"anthropic": os.environ["ANTHROPIC_API_KEY"]},
    # Or use {"openai": os.environ["OPENAI_API_KEY"]}
)

Auto-trace OpenAI calls

from openai import OpenAI
import prismbrain

gb = prismbrain.PrismBrain(api_key="gb_your_key")
client = prismbrain.wrap_openai(OpenAI(), gb)

# All completions are now traced automatically
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}]
)

Auto-trace Anthropic calls

from anthropic import Anthropic
import prismbrain

gb = prismbrain.PrismBrain(api_key="gb_your_key")
client = prismbrain.wrap_anthropic(Anthropic(), gb)

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello"}]
)

Group OpenAI and Anthropic calls into one trace

When one user request makes multiple wrapped provider calls, put them in a single trace_run scope. PrismBrain sends one trace with each provider call as a child node:

with gb.trace_run("user request"):
    openai_response = openai_client.chat.completions.create(...)
    anthropic_response = anthropic_client.messages.create(...)

Calls outside a trace_run scope continue to create one trace per provider request.

LangChain

Install the optional LangChain integration:

pip install "prismbrain[langchain]" langchain-openai

Attach the callback handler to LangChain models:

import os
import prismbrain
from langchain_openai import ChatOpenAI

pb = prismbrain.PrismBrain(api_key=os.environ["PRISMBRAIN_API_KEY"])
handler = prismbrain.PrismBrainCallbackHandler(pb)
llm = ChatOpenAI(model="gpt-4o-mini", callbacks=[handler])

Every invoke, tool call, error, token count, and measured latency is captured automatically.

LangGraph

Install the optional LangGraph integration:

pip install "prismbrain[langgraph]" langgraph langchain-openai

Pass the same handler through the compiled graph config:

graph.invoke(state, config={"callbacks": [handler]})

This captures graph nodes, nested chains, LLM calls, tools, errors, real latency, and token usage without manual trace() calls.

Decorators

import prismbrain

gb = prismbrain.PrismBrain(api_key="gb_your_key")

@prismbrain.trace_function(gb)
def process_data(items):
    # Automatically traces errors and performance
    ...

@prismbrain.trace_endpoint(gb)
def handle_request():
    # Traces API endpoint calls
    ...

Framework Middleware

FastAPI

from fastapi import FastAPI
import prismbrain
from prismbrain.middleware import FastAPIMiddleware

app = FastAPI()
gb = prismbrain.PrismBrain(api_key="gb_your_key")
app.add_middleware(FastAPIMiddleware, prismbrain=gb)

Flask

from flask import Flask
import prismbrain
from prismbrain.middleware import FlaskMiddleware

app = Flask(__name__)
gb = prismbrain.PrismBrain(api_key="gb_your_key")
FlaskMiddleware(app, prismbrain=gb)

Django

Add to settings.py:

PRISMBRAIN_API_KEY = "gb_your_key"

MIDDLEWARE = [
    "prismbrain.middleware.DjangoMiddleware",
    ...
]

Publishing to PyPI

cd packages/prismbrain-python
pip install build twine
python -m build
twine upload dist/*

License

MIT