pipecat-memorysync 1.0.0__tar.gz → 1.0.1__tar.gz

pipecat_memorysync-1.0.1/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+All notable changes to `pipecat-memorysync` are documented here.
+
+## 1.0.1 — 2026-08-29
+
+- Metadata only: the source repository moved to
+  `https://github.com/memorysyncio/memorysync-pipecat`; project URLs updated.
+  No code changes.
+
+## 1.0.0 — 2026-08-29
+
+Initial release.
+
+- `MemorySyncMemoryService`, a `FrameProcessor` for the position between the
+  user context aggregator and the LLM service.
+- Budgeted memory recall (default 1.2 s hard timeout) injected into every
+  `LLMContextFrame` as a guarded system message — a slow or unreachable
+  backend degrades to an unenriched frame, never a stalled reply.
+- Delta-only capture with deterministic idempotency seeds: only turns not
+  seen before are persisted, with role fidelity for user and assistant.
+- Injection exclusion: the injected memory block is never re-captured.
+- Graceful `EndFrame` flush (bounded 3 s window) and `CancelFrame` salvage.
+- Tested with Pipecat v1.8.1 through `pipecat.tests.utils.run_test`
+  (14-test suite).

{pipecat_memorysync-1.0.0 → pipecat_memorysync-1.0.1}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.5
 Name: pipecat-memorysync
-Version: 1.0.0
+Version: 1.0.1
 Summary: MemorySync for Pipecat: budgeted memory recall that never stalls a voice reply, delta-only conversation persistence with idempotency seeds, and a pipeline that cannot be broken by a memory outage.
 Project-URL: Homepage, https://docs.memorysync.io/guides/pipecat
 Project-URL: Documentation, https://docs.memorysync.io/guides/pipecat
-Project-URL: Repository, https://github.com/Rafay121/memorysync-plugins
+Project-URL: Repository, https://github.com/memorysyncio/memorysync-pipecat
+Project-URL: Changelog, https://github.com/memorysyncio/memorysync-pipecat/blob/main/CHANGELOG.md
 Author-email: MemorySync <support@memorysync.io>
 License-Expression: MIT
 Keywords: agents,long-term-memory,memory,memorysync,pipecat,voice
@@ -21,14 +22,22 @@ Requires-Dist: httpx<1,>=0.25
 Requires-Dist: pipecat-ai<2,>=1.0.0
 Description-Content-Type: text/markdown
 
-# pipecat-memorysync
+# memorysync-pipecat
 
 [MemorySync](https://memorysync.io) for [Pipecat](https://github.com/pipecat-ai/pipecat) —
 long-term memory for voice pipelines that never stalls a reply and never
-re-stores what it already knows.
+re-stores what it already knows. PyPI package: **`pipecat-memorysync`**.
+
+Built and maintained by the [MemorySync](https://memorysync.io) team —
+MemorySync is our product, and this integration is actively maintained
+alongside it.
+
+**Tested with Pipecat v1.8.1** (`pipecat-ai>=1.0.0,<2`).
 
 ```bash
 pip install pipecat-memorysync
+# or
+uv add pipecat-memorysync
 ```
 
 ## Where it sits
@@ -74,8 +83,7 @@ enriched or not, on time.
   stalled voice reply.
 - **Delta-only capture.** Only messages *not seen before* are stored, tracked
   by deterministic idempotency seeds. Growing a 50-message context does not
-  re-store 50 messages per turn (a real flaw in some in-tree memory services,
-  which re-send the entire context every frame — O(n²) writes per call).
+  re-store 50 messages per turn.
 - **Injection exclusion.** The memory block this service adds is never captured
   back as a new memory.
 - **Graceful end, salvaged abort.** On `EndFrame`, queued writes get a bounded
@@ -85,6 +93,25 @@ enriched or not, on time.
 - **Failure-proof.** HTTP errors, quota limits, and timeouts all degrade to
   "no memories this turn". Nothing propagates into the pipeline.
 
+## Running the example
+
+A single-file voice agent that remembers callers across calls lives in
+[`examples/foundational.py`](examples/foundational.py):
+
+```bash
+uv add pipecat-memorysync "pipecat-ai[deepgram,cartesia,openai,silero,runner,webrtc]"
+
+export MEMORYSYNC_API_KEY=ms_...   # https://app.memorysync.io
+export DEEPGRAM_API_KEY=...
+export CARTESIA_API_KEY=...
+export OPENAI_API_KEY=...
+
+python examples/foundational.py
+```
+
+Open `http://localhost:7860/client`, tell the bot your name and a preference,
+hang up, and connect again — it remembers.
+
 ## Configuration (`InputParams`)
 
 ```python
@@ -128,6 +155,10 @@ python -m venv venv && venv/Scripts/pip install -e . pipecat-ai pytest pytest-as
 venv/Scripts/python -m pytest tests -q    # 14 tests, run via pipecat's official test harness
 ```
 
+## Docs
+
+Full guide: [docs.memorysync.io/guides/pipecat](https://docs.memorysync.io/guides/pipecat)
+
 ## License
 
 MIT

{pipecat_memorysync-1.0.0 → pipecat_memorysync-1.0.1}/README.md

@@ -1,11 +1,19 @@
-# pipecat-memorysync
+# memorysync-pipecat
 
 [MemorySync](https://memorysync.io) for [Pipecat](https://github.com/pipecat-ai/pipecat) —
 long-term memory for voice pipelines that never stalls a reply and never
-re-stores what it already knows.
+re-stores what it already knows. PyPI package: **`pipecat-memorysync`**.
+
+Built and maintained by the [MemorySync](https://memorysync.io) team —
+MemorySync is our product, and this integration is actively maintained
+alongside it.
+
+**Tested with Pipecat v1.8.1** (`pipecat-ai>=1.0.0,<2`).
 
 ```bash
 pip install pipecat-memorysync
+# or
+uv add pipecat-memorysync
 ```
 
 ## Where it sits
@@ -51,8 +59,7 @@ enriched or not, on time.
   stalled voice reply.
 - **Delta-only capture.** Only messages *not seen before* are stored, tracked
   by deterministic idempotency seeds. Growing a 50-message context does not
-  re-store 50 messages per turn (a real flaw in some in-tree memory services,
-  which re-send the entire context every frame — O(n²) writes per call).
+  re-store 50 messages per turn.
 - **Injection exclusion.** The memory block this service adds is never captured
   back as a new memory.
 - **Graceful end, salvaged abort.** On `EndFrame`, queued writes get a bounded
@@ -62,6 +69,25 @@ enriched or not, on time.
 - **Failure-proof.** HTTP errors, quota limits, and timeouts all degrade to
   "no memories this turn". Nothing propagates into the pipeline.
 
+## Running the example
+
+A single-file voice agent that remembers callers across calls lives in
+[`examples/foundational.py`](examples/foundational.py):
+
+```bash
+uv add pipecat-memorysync "pipecat-ai[deepgram,cartesia,openai,silero,runner,webrtc]"
+
+export MEMORYSYNC_API_KEY=ms_...   # https://app.memorysync.io
+export DEEPGRAM_API_KEY=...
+export CARTESIA_API_KEY=...
+export OPENAI_API_KEY=...
+
+python examples/foundational.py
+```
+
+Open `http://localhost:7860/client`, tell the bot your name and a preference,
+hang up, and connect again — it remembers.
+
 ## Configuration (`InputParams`)
 
 ```python
@@ -105,6 +131,10 @@ python -m venv venv && venv/Scripts/pip install -e . pipecat-ai pytest pytest-as
 venv/Scripts/python -m pytest tests -q    # 14 tests, run via pipecat's official test harness
 ```
 
+## Docs
+
+Full guide: [docs.memorysync.io/guides/pipecat](https://docs.memorysync.io/guides/pipecat)
+
 ## License
 
 MIT

pipecat_memorysync-1.0.1/examples/foundational.py

@@ -0,0 +1,128 @@
+#
+# Foundational example: a voice agent that remembers callers across calls.
+#
+# MemorySyncMemoryService sits between the user context aggregator and the
+# LLM: every LLMContextFrame is enriched with relevant long-term memories
+# under a hard time budget, and new turns are persisted in the background.
+# A slow or unreachable memory backend can never stall the voice reply.
+#
+# Run (choose any transport supported by the Pipecat runner):
+#
+#   uv add pipecat-memorysync "pipecat-ai[deepgram,cartesia,openai,silero,runner,webrtc]"
+#   export MEMORYSYNC_API_KEY=ms_...   # https://app.memorysync.io
+#   export DEEPGRAM_API_KEY=...
+#   export CARTESIA_API_KEY=...
+#   export OPENAI_API_KEY=...
+#   python foundational.py
+#
+# Then open http://localhost:7860/client, talk to the bot, tell it your
+# name and a preference, hang up, and call again: it remembers.
+#
+
+import os
+
+from dotenv import load_dotenv
+from loguru import logger
+
+from pipecat.audio.vad.silero import SileroVADAnalyzer
+from pipecat.frames.frames import LLMRunFrame
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.task import PipelineParams, PipelineTask
+from pipecat.processors.aggregators.llm_context import LLMContext
+from pipecat.processors.aggregators.llm_response_universal import (
+    LLMContextAggregatorPair,
+    LLMUserAggregatorParams,
+)
+from pipecat.runner.types import RunnerArguments
+from pipecat.runner.utils import create_transport
+from pipecat.services.cartesia.tts import CartesiaTTSService
+from pipecat.services.deepgram.stt import DeepgramSTTService
+from pipecat.services.openai.llm import OpenAILLMService
+from pipecat.transports.base_transport import BaseTransport, TransportParams
+
+from pipecat_memorysync import MemorySyncMemoryService
+
+load_dotenv(override=True)
+
+SYSTEM_INSTRUCTION = (
+    "You are a friendly voice assistant with long-term memory. "
+    "Relevant facts about the caller may appear as background memory context. "
+    "Use them naturally; never read them out verbatim. "
+    "Your answers are spoken aloud, so keep them short and conversational."
+)
+
+transport_params = {
+    "webrtc": lambda: TransportParams(audio_in_enabled=True, audio_out_enabled=True),
+}
+
+
+async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
+    logger.info("Starting bot")
+
+    stt = DeepgramSTTService(api_key=os.environ["DEEPGRAM_API_KEY"])
+
+    tts = CartesiaTTSService(
+        api_key=os.environ["CARTESIA_API_KEY"],
+        voice_id="71a7ad14-091c-4e8e-a314-022ece01c121",
+    )
+
+    llm = OpenAILLMService(api_key=os.environ["OPENAI_API_KEY"])
+
+    # Long-term memory. In a real deployment, derive user_id from the
+    # caller's identity (phone number, account id, ...) so each caller
+    # gets their own memories.
+    memory = MemorySyncMemoryService(
+        api_key=os.environ["MEMORYSYNC_API_KEY"],
+        user_id=os.environ.get("MEMORYSYNC_USER_ID", "demo-caller"),
+    )
+
+    context = LLMContext([{"role": "system", "content": SYSTEM_INSTRUCTION}])
+    context_aggregator = LLMContextAggregatorPair(
+        context,
+        user_params=LLMUserAggregatorParams(vad_analyzer=SileroVADAnalyzer()),
+    )
+
+    pipeline = Pipeline(
+        [
+            transport.input(),
+            stt,
+            context_aggregator.user(),
+            memory,  # enrich with memories + capture new turns, on budget
+            llm,
+            tts,
+            transport.output(),
+            context_aggregator.assistant(),
+        ]
+    )
+
+    task = PipelineTask(
+        pipeline,
+        params=PipelineParams(enable_metrics=True, enable_usage_metrics=True),
+        idle_timeout_secs=runner_args.pipeline_idle_timeout_secs,
+    )
+
+    @transport.event_handler("on_client_connected")
+    async def on_client_connected(transport, client):
+        logger.info("Client connected")
+        await task.queue_frames([LLMRunFrame()])
+
+    @transport.event_handler("on_client_disconnected")
+    async def on_client_disconnected(transport, client):
+        logger.info("Client disconnected")
+        await task.cancel()
+
+    runner = PipelineRunner(handle_sigint=runner_args.handle_sigint)
+    await runner.run(task)
+
+
+async def bot(runner_args: RunnerArguments):
+    """Main bot entry point compatible with the Pipecat runner."""
+    transport = await create_transport(runner_args, transport_params)
+    await run_bot(transport, runner_args)
+
+
+if __name__ == "__main__":
+    from pipecat.runner.run import main
+
+    main()

{pipecat_memorysync-1.0.0 → pipecat_memorysync-1.0.1}/pyproject.toml

@@ -29,7 +29,8 @@ dependencies = [
 [project.urls]
 Homepage = "https://docs.memorysync.io/guides/pipecat"
 Documentation = "https://docs.memorysync.io/guides/pipecat"
-Repository = "https://github.com/Rafay121/memorysync-plugins"
+Repository = "https://github.com/memorysyncio/memorysync-pipecat"
+Changelog = "https://github.com/memorysyncio/memorysync-pipecat/blob/main/CHANGELOG.md"
 
 [tool.hatch.version]
 path = "src/pipecat_memorysync/_version.py"

{pipecat_memorysync-1.0.0 → pipecat_memorysync-1.0.1}/src/pipecat_memorysync/_version.py

@@ -1,3 +1,3 @@
 """Version for pipecat-memorysync. Single source of truth."""
 
-__version__ = "1.0.0"
+__version__ = "1.0.1"

{pipecat_memorysync-1.0.0 → pipecat_memorysync-1.0.1}/tests/test_service.py

@@ -28,12 +28,20 @@ def context_of(messages: List[dict]) -> LLMContext:
 
 
 async def drive(service: Any, *contexts: LLMContext) -> None:
-    """Send one LLMContextFrame per context through the real harness."""
+    """Send one LLMContextFrame per context through the real harness.
+
+    ``start_timeout`` defaults to 1s inside pipecat's harness, which the
+    FIRST test in the session routinely blows on a cold shared CI runner
+    (import machinery + task spin-up), failing it with a TimeoutError
+    before any frame flows. A generous ceiling costs nothing when the
+    pipeline starts fast — it is not a sleep — and removes the flake.
+    """
     frames = [LLMContextFrame(context=ctx) for ctx in contexts]
     await run_test(
         service,
         frames_to_send=frames,
         expected_down_frames=[LLMContextFrame] * len(frames),
+        start_timeout=30.0,
     )