Vapi + Memanto

A Vapi assistant starts every call from zero. It doesn’t know your policies unless they are in the prompt, and it repeats on Friday the mistake it was corrected for on Monday. memanto-vapi is a single webhook that gives the assistant a memory it keeps between calls.

Knowledge at call start

Your organization’s knowledge and the lessons learned so far arrive in the prompt as {{memanto_context}}.

Memory tools mid-call

memanto_recall looks things up; memanto_remember saves what the agent learns.

Learns from each call

At end-of-call-report the conversation becomes typed memories — mistakes, corrections, better answers, facts.

Never delays a call

Lookup is capped at 3s inside Vapi’s 7.5s assistant-request budget, and fails open.

How It Works

Call starts  →  assistant-request  →  recall  →  {{memanto_context}} in the prompt
                                                        │
During call  →  tool-calls        →  memanto_recall / memanto_remember
                                                        │
Call ends    →  end-of-call-report → extract typed memories → Memanto

Everything lives in one Memanto agent, so you can read, correct, and audit what the voice agent knows with the CLI or the web UI.

Two scopes

shared (default)
caller

One memory for the whole assistant: your knowledge plus the lessons from every call. Every caller benefits from what the agent learned yesterday, and no personal caller details are stored, so nothing can leak between callers.

MEMANTO_VAPI_SCOPE=shared

Everything above, plus memories only that caller sees: their preferences, open issues, and commitments made to them. Their tag is an HMAC of customer.number (or customer.externalId for web and chat calls) keyed with a salt you set, so raw phone numbers are never stored.

MEMANTO_VAPI_SCOPE=caller
MEMANTO_VAPI_CALLER_SALT=$(openssl rand -hex 32)

In caller scope the context has two parts:

Knowledge and lessons learned:
- [instruction] Refund window: refunds are accepted within 30 days (2026-09-01)
- [error] Do not quote weekend hours as 9-5; they are 10-4 (2026-09-14)

About this caller:
- [preference] Prefers morning delivery slots (2026-08-02)
- [commitment] Promised a callback about invoice 4471 (2026-09-15)

Keep MEMANTO_VAPI_CALLER_SALT secret and stable. Changing it cuts every caller off from their existing memories.

The server decides whose memories a call may read and write, from the caller Vapi reports. The model never passes a caller ID, so a prompt injection cannot reach another caller’s memories, and every result is re-checked against the caller’s tag before it is returned. In caller scope, anything the agent saves mid-call is private to the caller on the line; shared lessons come only from end-of-call extraction, whose prompt excludes caller details.

Prerequisites

Python 3.10+
Memanto 0.2.21+ and a Moorcheh API key (or an on-prem Memanto backend)
A Vapi account, a saved assistant, and a public HTTPS URL for the webhook

Install and run

Install

pip install memanto-vapi

Until memanto-vapi is on PyPI, install it from a checkout of the Memanto repo: pip install ./integrations/vapi (see GitHub source).

Configure

export MOORCHEH_API_KEY=your_key_xxxxxxxxxxxxxxxxxx
export MEMANTO_VAPI_AGENT_ID=acme-support        # Memanto agent for this assistant
export MEMANTO_VAPI_SECRET=$(openssl rand -hex 32)
export MEMANTO_VAPI_ASSISTANT_ID=your_vapi_assistant_id

Serve

memanto-vapi serve --port 8080

The webhook is at POST /vapi/webhook, with GET /health for status. For local testing, expose it with ngrok http 8080.

The Memanto agent is created on first start. Run one instance per agent — Memanto keeps one active session per agent, so instances sharing ~/.memanto would sign each other out.

Load your knowledge

Anything stored in the Memanto agent is available to the voice agent. Add it before starting the webhook — activating an agent elsewhere signs out a running webhook until its next call:

memanto agent activate acme-support
memanto remember "Refunds are accepted within 30 days of delivery" --type instruction
memanto upload handbook.pdf

Review and correct what the agent learned in the same place:

memanto recall "weekend hours"
memanto edit <memory-id> --content "Weekend hours are 10-4"

Configure Vapi

Create a credential

In the Vapi dashboard, create a Bearer Token credential whose token is MEMANTO_VAPI_SECRET. Requests without it are rejected with 401; the legacy X-Vapi-Secret header is also accepted.

Create the tools

memanto-vapi tools --server-url https://your-host/vapi/webhook --credential-id <credential id>
# add --scope caller if the webhook runs in caller scope

Create each printed definition with POST https://api.vapi.ai/tool, then add both tool IDs to the assistant’s model.toolIds.

Use the variable in the prompt

What you know from earlier calls:
{{memanto_context}}

Use memanto_recall when you are unsure how to answer or handle a request.
Use memanto_remember when you are corrected, or you learn something that
would help on future calls.

Point Vapi at the webhook

Set the URL and credential on the phone number, so inbound calls ask it which assistant to use (don’t also attach an assistant to the number), and on the assistant (server.url) with end-of-call-report in serverMessages, so calls are learned from.

Outbound, web, and chat calls

Vapi only sends assistant-request for inbound phone calls. For calls you start yourself, build the overrides at call creation:

from memanto.cli.client.sdk_client import SdkClient
from memanto_vapi import VapiMemory

memory = VapiMemory(SdkClient(api_key=...), agent_id="acme-support")

overrides = await memory.build_assistant_overrides({})
# caller scope — pass the person:
# await memory.build_assistant_overrides({"customer": {"number": "+15551234567"}})

# POST https://api.vapi.ai/call
#   {"assistantId": ..., "customer": ..., "assistantOverrides": overrides}

Tools and end-of-call learning work the same for these calls. In caller scope the call must carry customer.number or customer.externalId for the caller’s private half; the shared half always works.

Mount in your own app

from fastapi import FastAPI
from memanto_vapi import VapiMemory, create_router

memory = VapiMemory(client, agent_id="acme-support")
app = FastAPI()
app.include_router(create_router(memory, secret=SECRET, assistant_id=ASSISTANT_ID))

Unlike create_app, create_router does not activate the Memanto session at startup — call memory.ensure_ready() in your own startup hook so the first caller doesn’t wait for it.

Behavior and limits

Behavior	Detail
Fail-open recall	Capped at `recall_timeout` (3s). On timeout or error the call starts with an empty `{{memanto_context}}` and a warning is logged.
Bounded context	`recall_limit` (10) recent and 10 relevant memories per section, `max_context_chars` (4000) in total.
Background learning	`end-of-call-report` is acknowledged immediately and processed afterwards. Calls where the caller never spoke are skipped.
No caller data in shared scope	The extraction prompt excludes personal details, and `memanto_remember` stores everything as shared. Use caller scope for per-person memory.
Retries are ignored	End-of-call memories carry a `retained-<call id>` tag, so a webhook Vapi re-delivers is not learned from twice.
Possible duplicates	Within one call something can be saved twice — once by the tool while talking, once by extraction at the end.
Reserved tag prefix	Tags starting with `caller-` mark private memories; shared lookups skip anything carrying one.
Agent-wide analysis	Conflict scans and daily summaries cover the whole agent, including every caller’s memories in caller scope.

Shared memory across integrations

All Memanto integration packages use the same Moorcheh-backed agents when they share an agent_id:

Integration	Package	What it does
Vapi	`memanto-vapi`	Webhook giving a Vapi voice agent knowledge, lessons, and optional per-caller memory.
`integrations/mcp`	`memanto-mcp`	MCP server for Claude Desktop, Cursor, etc.
`integrations/agentcore`	`memanto-agentcore`	Recall/retain wrapper for Bedrock AgentCore Runtime handlers.
`integrations/crewai`	`crewai-memanto`	CrewAI tools for multi-agent memory.
`integrations/langgraph`	`langgraph-memanto`	LangGraph `BaseStore`, nodes, and tools.

Integrations

Vapi

Vapi + Memanto

Knowledge at call start

Memory tools mid-call

Learns from each call

Never delays a call

How It Works

Two scopes

Prerequisites

Install and run

Load your knowledge

Configure Vapi

Outbound, web, and chat calls

Mount in your own app

Behavior and limits

Shared memory across integrations

Next Steps

​Vapi + Memanto

Knowledge at call start

Memory tools mid-call

Learns from each call

Never delays a call

​How It Works

​Two scopes

​Prerequisites

​Install and run

​Load your knowledge

​Configure Vapi

​Outbound, web, and chat calls

​Mount in your own app

​Behavior and limits

​Shared memory across integrations

​Next Steps

Vapi + Memanto

How It Works

Two scopes

Prerequisites

Install and run

Load your knowledge

Configure Vapi

Outbound, web, and chat calls

Mount in your own app

Behavior and limits

Shared memory across integrations

Next Steps