Mem0 Integration¶

from fastagentic import App
from fastagentic.integrations.mem0 import Mem0Provider

app = App(
    title="My Agent",
    memory=Mem0Provider(api_key="..."),
)

app = App(memory=Mem0Provider())  # Auto-reads from env

from fastagentic.memory import MemoryProvider

class Mem0Provider(MemoryProvider):
    async def add(self, user_id: str, messages: list[dict], metadata: dict = None) -> str:
        """Add memories from conversation."""
        ...

    async def search(self, user_id: str, query: str, limit: int = 10) -> list[dict]:
        """Search user memories."""
        ...

    async def get_all(self, user_id: str) -> list[dict]:
        """Get all memories for user."""
        ...

    async def delete(self, user_id: str, memory_id: str) -> None:
        """Delete specific memory."""
        ...

from fastagentic import agent_endpoint
from fastagentic.memory import inject_memory

@agent_endpoint(
    path="/chat",
    runnable=...,
    memory=inject_memory(
        strategy="relevant",  # or "recent", "all"
        max_memories=10,
        min_relevance=0.7,
    ),
)
async def chat(message: str, ctx: AgentContext) -> str:
    # ctx.memories contains relevant memories
    # Automatically injected into agent context
    ...

from fastagentic import agent_endpoint

@agent_endpoint(path="/chat", runnable=...)
async def chat(message: str, ctx: AgentContext) -> str:
    # Search memories
    memories = await ctx.memory.search(
        user_id=ctx.user.id,
        query=message,
        limit=5,
    )

    # Add to conversation context
    memory_context = "\n".join([m["memory"] for m in memories])

    # After response, store new memories
    await ctx.memory.add(
        user_id=ctx.user.id,
        messages=[
            {"role": "user", "content": message},
            {"role": "assistant", "content": response},
        ],
    )

    return response

inject_memory(
    strategy="relevant",
    max_memories=10,
    min_relevance=0.7,  # Cosine similarity threshold
)

inject_memory(
    strategy="recent",
    max_memories=20,
    time_window_hours=24,
)

inject_memory(
    strategy="all",
    max_memories=50,
)

# Store with category
await ctx.memory.add(
    user_id=ctx.user.id,
    messages=[...],
    metadata={"category": "preferences"},
)

# Search by category
memories = await ctx.memory.search(
    user_id=ctx.user.id,
    query="...",
    filters={"category": "preferences"},
)

from fastagentic.memory import Mem0Provider, RedisProvider

app = App(
    # Long-term memory (Mem0)
    memory=Mem0Provider(api_key="..."),

    # Session memory (Redis) - cleared after session
    session_memory=RedisProvider(
        url="redis://localhost:6379",
        ttl_seconds=3600,  # 1 hour
    ),
)

from mem0 import Memory

# Use self-hosted mem0 with custom config
memory_config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "host": "localhost",
            "port": 6333,
        }
    },
    "llm": {
        "provider": "openai",
        "config": {
            "model": "gpt-4o-mini",
        }
    },
}

app = App(
    memory=Mem0Provider(config=memory_config),
)

# User A's memories never leak to User B
memories = await ctx.memory.search(
    user_id="user_a",  # Strictly scoped
    query="...",
)

from fastagentic import App

app = App(memory=Mem0Provider(...))

# Delete all memories for user
@app.post("/users/{user_id}/forget")
async def forget_user(user_id: str, ctx: AppContext):
    memories = await ctx.memory.get_all(user_id)
    for m in memories:
        await ctx.memory.delete(user_id, m["id"])
    return {"deleted": len(memories)}

Mem0Provider(
    api_key="...",
    encryption_key="...",  # Encrypt at rest
)

from fastagentic.integrations.zep import ZepProvider

app = App(
    memory=ZepProvider(
        api_key="...",
        # Zep automatically summarizes long conversations
        auto_summarize=True,
    ),
)

from fastagentic.memory import RedisProvider

app = App(
    memory=RedisProvider(
        url="redis://localhost:6379",
        prefix="memory:",
    ),
)