MemorySync Memory

The pipecat-memorysync integration gives Pipecat voice agents long-term, cross-session memory backed by MemorySync — budgeted recall that never stalls a reply.

Overview

The pipecat-memorysync integration connects MemorySync, a managed long-term memory layer, to Pipecat voice pipelines. It ships one FrameProcessor: MemorySyncMemoryService sits between the user context aggregator and the LLM service, enriches every LLMContextFrame with relevant memories under a hard time budget (default 1.2 s), and mines the same frames for new turns to persist in the background — so the frame is always pushed on time, enriched or not. Capture is delta-only with deterministic idempotency seeds, and the injected memory block is excluded from capture, so recalled context never re-enters storage.

Source Repository

Source code, foundational example, and issues for the Pipecat integration

Documentation

Full MemorySync guide for Pipecat pipelines

Website

Learn more about MemorySync

Dashboard

Manage your MemorySync account and API keys

Installation

This is a community-maintained package distributed separately from pipecat-ai:

uv add pipecat-memorysync

Requires pipecat-ai>=1.0.0 and Python 3.10+.

Prerequisites

MemorySync Account Setup

Before using the MemorySync integration, you need:

1. MemorySync API Key: Get one at app.memorysync.io
2. Set it as the MEMORYSYNC_API_KEY environment variable, or pass it as the api_key constructor argument.

Configuration

MemorySyncMemoryService

Inserted after the user context aggregator and before the LLM service. On each LLMContextFrame, fetches user-scoped memories from MemorySync under a hard budget and appends them as a system message to the context, then persists any new turns in the background.

user_id · str · required

Required — MemorySync memory is user-scoped. Use a stable end-user id.

api_key · str · default: "None"

MemorySync API key. Falls back to the MEMORYSYNC_API_KEY environment variable.

session_id · str · default: "None"

Stable id for this call, used to scope the conversation transcript. Auto-generated per service lifetime when absent.

params · InputParams · default: "InputParams()"

Runtime tuning, see below.

InputParams

top_k · int · default: "5"

Memories injected per turn.

recall_timeout · float · default: "1.2"

Hard recall budget in seconds. On timeout the frame proceeds unenriched — a slow memory backend can never stall a voice reply.

add_as_system_message · bool · default: "True"

Inject the memory block as a system message (else it is appended to the latest user message).

position · str · default: "\"end\""

Where the memory block lands in the message list ("start" or "end").

min_prompt_chars · int · default: "8"

Skip recall for user prompts shorter than this.

Usage

from pipecat.pipeline.pipeline import Pipeline
from pipecat_memorysync import MemorySyncMemoryService

memory = MemorySyncMemoryService(
    api_key="ms_...",       # or MEMORYSYNC_API_KEY env var
    user_id="caller-42",    # stable end-user id
    session_id="call-123",  # optional: scope to this call
)

pipeline = Pipeline([
    transport.input(),
    stt,
    context_aggregator.user(),
    memory,   # enrich with memories + capture new turns, on budget
    llm,
    tts,
    transport.output(),
    context_aggregator.assistant(),
])

Reads and writes both degrade gracefully — HTTP errors, quota limits, and timeouts all result in “no memories this turn” and nothing propagates into the pipeline. On EndFrame, queued writes get a bounded window to land so the call’s final exchange is never lost.

Compatibility

The integration requires pipecat-ai>=1.0.0 (tested with Pipecat v1.8.1, through pipecat.tests.utils.run_test — the framework’s own harness). Check the source repository for the latest tested version and changelog.