Skip to main content
Interested in transferring your data from Mem0 to Honcho? This guide covers why to switch, how to migrate your data, and differences between the two products.

Why Honcho?

Mem0 & Honcho both store your data. Only Honcho reasons about it. Read more about our approach. Compounding Insights - Honcho extracts insights that build on each other over time. The more your users interact, the richer and more accurate their profiles become. Superior Performance - Higher accuracy on memory retrieval benchmarks with faster inference times (more details soon!). Competitive Pricing - Mem0 charges for retrieval, not ingestion. Meaning you pay to access your own data. Honcho offers straightforward pricing with a generous free tier. Advanced Multi-Peer Sessions - Honcho offers configurable observation settings (who builds memories about whom), representation-based queries between participants, and first-class peer objects.
We would love to support the transfer and cost—just book a call!

Quick Migration

For the best results, we recommend importing your raw messages directly into Honcho. This gives Honcho the full context to build rich, accurate representations and enables features like session summaries. However, if you’d like to get started quickly, you can migrate your existing Mem0 memories directly as observations.
Get your API key at app.honcho.dev/api-keys. New accounts start with $100 credits.
# pip install mem0ai honcho-ai
from mem0 import MemoryClient
from honcho import Honcho

# Export from Mem0
mem0 = MemoryClient(api_key="your-mem0-api-key")
memories = mem0.get_all(filters={"user_id": "user123"}, page_size=100)

# Initialize Honcho
honcho = Honcho(api_key="your-honcho-api-key")
user = honcho.peer("user123")
session = honcho.session("imported")
session.add_peers([user])

# Import memories directly as observations
observations = []
for memory in memories['results']:
    content = memory.get("memory") or memory.get("messages", [{}])[0].get("content", "")
    if content:
        observations.append({"content": content, "session_id": "imported"})

# Batch create observations (up to 100 at a time)
if observations:
    user.observations.create(observations)

print(f"Migrated {len(observations)} memories as observations!")
That’s it! The user’s Mem0 memories are now searchable in Honcho as observations. For richer representations with deductive reasoning and session summaries, consider importing your raw messages as described in the Step-by-Step Migration section. For more details on replacing Mem0 API calls with Honcho equivalents go to API Comparison.

Step-by-Step Migration

Prefer a more detailed walkthrough? Follow these steps:

1. Export User Messages

Importing raw user messages gives Honcho the full conversational context to build the most accurate representations. We recommend using a data structure that preserves the session and peer structure.
If you need any help with this transfer or have any questions, please reach out at [email protected] or book a call!
Alternatively, if you want to import the Mem0 memories, follow the example above and find more info in Mem0’s export API documentation.

2. Install the Honcho SDK

uv add honcho-ai

3. Initialize the Honcho Client

Get your API key at app.honcho.dev/api-keys. New accounts start with $100 credits.
from honcho import Honcho

honcho = Honcho( api_key="your-api-key" )

4. Import Your Data

This is a possible implementation using raw user messages. Adapt the data structure to match your exported format.
# Example data structure (preserving message history with timestamps):
exported_data = {
    "session-1": {
        "user123": [
            {"content": "I prefer dark mode", "timestamp": "2024-01-15T10:30:00Z"},
            {"content": "My name is Alex", "timestamp": "2024-01-15T10:31:00Z"},
        ],
        "user456": [
            {"content": "I work in finance", "timestamp": "2024-01-15T11:00:00Z"},
            {"content": "I like concise responses", "timestamp": "2024-01-15T11:02:00Z"},
        ],
    },
    "session-2": {
        "user123": [
            {"content": "Meeting notes from last week...", "timestamp": "2024-01-16T09:00:00Z"},
        ],
    }
}

# Import into Honcho
for session_name, users in exported_data.items():
    session = honcho.session(session_name)

    for user_id, messages in users.items():
        peer = honcho.peer(user_id)
        session.add_peers([peer])

        # Sort by timestamp to preserve message order
        sorted_messages = sorted(messages, key=lambda m: m["timestamp"])
        session.add_messages([peer.message(m["content"]) for m in sorted_messages])

5. Update Your Application Code

Reference the API Comparison to replace your Mem0 API calls with the Honcho equivalents.

API Comparison

Core Operations

OperationMem0HonchoNotes
InitializeMemoryClient(api_key=...)Honcho(api_key=...)
Identityuser_id string parampeer = honcho.peer("id")Peers can be users or AI agents
Add messagesclient.add(messages, user_id=...)session.add_messages([peer.message(...)])Session-scoped, triggers reasoning
Add observationspeer.observations.create([...])Direct observation or “memory” import, no processing
Searchclient.search(query, filters={"user_id": ...})peer.search(query) or peer.observations.query(...)Scoped to peer or session
List allclient.get_all(filters={"user_id": ...})session.get_messages() or peer.observations.list()Messages or observations
Updateclient.update(memory_id, data=...)honcho.update_message(message, metadata=...)Metadata updates only
Deleteclient.delete(memory_id)peer.observations.delete(id) or session.delete()Observation or session-level

Honcho-Only Capabilities

Mem0 requires manual assembly of context from search() results. Honcho’s session.get_context() returns a ready-to-use SessionContext object with built-in token limits, auto-included summaries, and format helpers (.to_openai(), .to_anthropic()).

Get Context

Learn more about token-optimized context retrieval
Mem0’s search() returns basic vector, semantic, or raw memory matches. Honcho’s peer.chat() enables your agent to reason about what it knows—returning synthesized natural language insights with streaming support and scoped queries.

Dialectic Endpoint

Learn more about inference-powered queries
Additional features with no Mem0 equivalent:
Honcho MethodDescriptionUse Case
peer.card()Stable biographical facts (name, preferences, background)User profiles, personalization
session.working_rep(peer)Cached psychological analysis (mental state, intentions)Real-time adaptation
session.get_summaries()Auto-generated short/long session summariesConversation continuity
SessionPeerConfigConfigure observation settings (who learns about whom)Privacy controls, role-based learning

Next Steps

Questions? Join our Discord or open an issue on GitHub.