DSPy

Connect your DSPy-based application to Latitude Telemetry to observe programs per feature and run evaluations.

This integration is only available in the Python SDK.

Overview

This guide shows you how to integrate Latitude Telemetry into an existing application that uses the DSPy framework for building modular LLM programs.

After completing these steps:

• Every DSPy program execution can be captured as a log in Latitude.
• Logs are grouped under a prompt, identified by a path, inside a Latitude project.
• You can inspect inputs/outputs, measure latency, and debug DSPy-powered features from the Latitude dashboard.

You’ll keep calling DSPy exactly as you do today — Telemetry simply observes and enriches those calls.

---

Requirements

Before you start, make sure you have:

• A Latitude account and API key
• A Latitude project ID
• A Python-based project that uses DSPy

That’s it — prompts do not need to be created ahead of time.

---

Steps

1. Install requirements

   Add the Latitude Telemetry package to your project:

   pip

   pip install latitude-telemetry
   
2. Initialize Latitude Telemetry

   Create a single Telemetry instance when your app starts.

   You must enable the DSPy instrumentor so Telemetry can trace it.

   telemetry.py

   import os
   from latitude_telemetry import Telemetry, Instrumentors, TelemetryOptions
   
   telemetry = Telemetry(
       os.environ["LATITUDE_API_KEY"],
       TelemetryOptions(
           instrumentors=[Instrumentors.DSPy],  # This enables automatic tracing for DSPy
       ),
   )
   

   The Telemetry instance should only be created once. Initialize it before importing DSPy so program executions are automatically traced.

3. Wrap your DSPy-powered feature

   Wrap the code that runs DSPy programs using telemetry.capture.

   You can use the capture method as a decorator (recommended) or as a context manager:

   Using decorator (recommended)

   from telemetry import telemetry
   import dspy
   
   # Configure DSPy with your LLM
   lm = dspy.LM("openai/gpt-4o")
   dspy.configure(lm=lm)
   
   # Define your DSPy signature and module
   class QA(dspy.Signature):
       """Answer questions with short responses."""
       question: str = dspy.InputField()
       answer: str = dspy.OutputField()
   
   qa_module = dspy.Predict(QA)
   
   @telemetry.capture(
       project_id=123,  # The ID of your project in Latitude
       path="generate-support-reply",  # Add a path to identify this prompt in Latitude
   )
   def generate_support_reply(input: str) -> str:
       # Your regular DSPy code here
       result = qa_module(question=input)
   
       # You can return anything you want — the value is passed through unchanged
       return result.answer
   

   Using context manager

   from telemetry import telemetry
   import dspy
   
   # Configure DSPy with your LLM
   lm = dspy.LM("openai/gpt-4o")
   dspy.configure(lm=lm)
   
   # Define your DSPy signature and module
   class QA(dspy.Signature):
       """Answer questions with short responses."""
       question: str = dspy.InputField()
       answer: str = dspy.OutputField()
   
   qa_module = dspy.Predict(QA)
   
   def generate_support_reply(input: str) -> str:
       with telemetry.capture(
           project_id=123,  # The ID of your project in Latitude
           path="generate-support-reply",  # Add a path to identify this prompt in Latitude
       ):
           # Your regular DSPy code here
           result = qa_module(question=input)
   
           # You can return anything you want — the value is passed through unchanged
           return result.answer
   

   The path:

   • Identifies the prompt in Latitude
   • Can be new or existing
   • Should not contain spaces or special characters (use letters, numbers, - _ / .)

---

Seeing your logs in Latitude

Once your feature is wrapped, logs will appear automatically.

1. Open the prompt in your Latitude dashboard (identified by path)
2. Go to the Traces section
3. Each execution will show:
   • Input and output messages
   • Model and token usage
   • Latency and errors
   • One trace per feature invocation

Each DSPy program execution appears as a child span under the captured prompt execution, giving you a full, end-to-end view of what happened.

---

That’s it

No changes to your DSPy programs, no special return values, and no extra plumbing — just wrap the feature you want to observe.