AgentOps Memory Observability

How it works

1. Install opentelemetry-instrumentation-memorysync next to agentops.
2. agentops.init() registers AgentOps as the global OpenTelemetry tracer provider.
3. instrument_memorysync() wraps the MemorySync SDK once — every client in the process now emits standard OTel spans through whatever provider is active.
4. Your memory operations land in AgentOps traces next to your LLM calls. No adapter, no plugin, no AgentOps-specific code.

Before you start

1. An AgentOps account and API key, plus a MemorySync API key.
2. Python 3.9+ with the memorysync SDK 1.8+ in your app.

Install

pip install opentelemetry-instrumentation-memorysync agentops

Set up

Step 1 — two lines at startup

Order doesn’t matter — the instrumentor binds the active provider late, so it works before or after agentops.init():

import agentops
from opentelemetry.instrumentation.memorysync import instrument_memorysync

agentops.init()          # registers AgentOps as the global OTel provider
instrument_memorysync()  # before or after init() — both work

Step 2 — use the SDK as normal

Nothing else changes. Every operation now produces a span:

from memorysync import MemorySyncClient

client = MemorySyncClient(api_key="ms_...", base_url="https://api.memorysync.io")
client.add("Prefers window seats", source="chat")   # span: memorysync.add
client.query("seating preferences", k=5)            # span: memorysync.query

Zero-code alternative

The package registers the standard OTel entry point, so the CLI wrapper also works with no source changes:

opentelemetry-instrument python app.py

What flows into your traces

add_turn sends one turn to fact extraction and does not store the turn itself, so its span reports the extraction receipt (processing_status: distilling, skipped_non_user_turn, skipped_low_value, skipped_replay, or skipped over the plan limit) rather than a memory id. The conversation-history and framework-state methods exist in the memorysync SDK 1.10.0 and later; with an older SDK installed, the memory operations are traced as usual.

A memorysync.client.operation.duration histogram is recorded per call for latency dashboards.

Privacy: content is never recorded by default

Memory content is customer data. By default the spans carry counts, identifiers, scores, and latencies — never memory text, query text, or recalled context. Opt in explicitly with instrument_memorysync(capture_content=True) or MEMORYSYNC_OTEL_CAPTURE_CONTENT=true; even then input is truncated to 500 characters and at most 5 result texts of 200 characters each are recorded.

Engineering guarantees

• Instrumentation can never break the app. Attribute extraction is fully guarded; results and exceptions pass through untouched; spans always end.
• Full sync/async parity — both MemorySyncClient and AsyncMemorySyncClient, all twenty-three operations (the incumbent wrapper skips history on cloud clients).
• Errors are first-class: failed calls produce ERROR spans with error.type and the HTTP status, and the original exception is re-raised unchanged.
• Idempotent lifecycle: double-instrument is a no-op; uninstrument_memorysync() restores the original methods.

Troubleshooting

• No memory spans in AgentOps — confirm agentops.init() actually ran in the same process, and that instrument_memorysync() was called before the operations you expected to see.
• Memory text missing from spans — that’s the privacy default. Opt in with capture_content=True if you truly need it.
• Double-instrumented by accident — harmless; the second call is a no-op.
• Need to detach — uninstrument_memorysync() restores the original client methods.

Supported versions

Where to go next