Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.memanto.ai/llms.txt

Use this file to discover all available pages before exploring further.

​
Memanto - Memory that AI Agents Love!

Memanto is a production-ready memory system for AI agents that gives them persistent, semantic long-term memory across conversations, sessions, and workflows.

​
What Problem Does It Solve?

LLM’s inherently lack persistent memory, they forget conversations between sessions. Agents need a way to:
  • Remember user preferences across sessions
  • Track decisions and commitments made during conversations
  • Store facts and context for faster, smarter responses
  • Manage long-running workflows with consistent state
  • Learn from interactions over time
Memanto solves this with a semantic memory system built for AI agents.

​
The 6 Principles of Production Agentic Memory

Based on our research and testing, we believe a robust memory system for AI agents should strive for six key characteristics:
  1. Queryable, not injectable: Agents generally benefit from the ability to query memory based on relevance to the current task, rather than receiving a static blob of context injected at the start of a conversation. It’s akin to giving an agent a librarian it can consult on demand versus a pre-assembled dossier.
  2. Temporally aware with decay: Not all memories carry equal weight. A deadline mentioned yesterday often has a different urgency than a preference stated six months ago. We’ve found that memory works best when it supports temporal queries, versioning, and relevance decay signals.
  3. Confidence and provenance tracking: A production system should ideally distinguish between explicitly stated facts, inferred patterns, and potentially outdated information. Providing provenance metadata helps agents calibrate their confidence and avoid making assertions on stale data.
  4. Typed and hierarchical: Different kinds of memory (e.g., episodic for past conversations, semantic for facts about the world/user, and procedural for how to do things) serve fundamentally different retrieval purposes and typically benefit from being stored and queried with appropriate type semantics.
  5. Contradiction aware: When new information conflicts with existing memory, the system should aim to flag the conflict rather than silently overwriting it. Left unchecked, unresolved contradictions can accumulate into “constraint drift,” which may erode the coherence of the agent’s world model over time.
  6. Zero overhead ingestion: For real-time workflows, memory should ideally be available for retrieval immediately at write time, minimizing indexing delays, mandatory LLM extraction steps, and graph construction bottlenecks.

​
How Memanto Solves These Challenges

Memanto is designed from the ground up to address these six principles:
  • Dynamic Retrieval: Rather than relying on massive context windows, Memanto provides an active search layer, allowing agents to pull exactly what they need, when they need it.
  • Rich Metadata & Typing: Every memory is stored with a specific type (e.g., fact, preference, decision) and a confidence score, providing the provenance and structure agents need to reason effectively.
  • Temporal Context: Memories belong to specific sessions and timelines, allowing agents to distinguish between outdated assumptions and recent commitments.
  • Instant Availability: Because it is built on Moorcheh.ai (a no-indexing semantic database), Memanto eliminates the indexing delays of traditional vector databases. Memories are searchable the exact millisecond they are written.

​
Key Advantages

​
Zero-Cost Ingestion Latency

Unlike traditional vector databases that index after writes, Memanto uses no-indexing semantic search. Memories are available for retrieval immediately no waiting.

​
State-of-the-Art Accuracy

Evaluated on LongMemEval and LoCoMo benchmarks:
  • 89.8% accuracy on LongMemEval
  • 87.1% accuracy on LoCoMo
Store memories with semantic meaning and retrieve them intelligently by relevance, not just keywords. For example, a query for “How should we contact the user?” will successfully match a memory stating “User prefers email communication” even without exact keyword overlap.

​
Built on Moorcheh

Memanto uses Moorcheh.ai, the world’s only no-indexing semantic database. Compared to traditional vector databases:
FeatureTraditional VDBMoorcheh
Write-to-SearchMinutes (indexing)Instant
AccuracyApproximate (ANN)Exact
Idle Costs$$$$ (always running)$0
ComputationHeavy (indexing)Efficient

​
Core Concepts

Before diving in, here are the core building blocks of Memanto:
  • Agents: A persistent identity with its own isolated memory namespace (e.g., customer-support-bot).
  • Sessions: A 6-hour active window for an agent. Memories created in one session persist forever and are available in all future sessions.
  • Memories: A semantic unit of information (e.g., “User prefers email”) stored with a specific type and confidence score.

​
What You Can Build

Use CaseExampleBenefit
Customer SupportAgent remembers past issues, preferences, ticketsFaster resolution, better context
AI AssistantsAssistant recalls your style, preferences, commitmentsMore personalized interactions
Agent WorkflowsMulti-step processes maintain state across sessionsReliable long-running automation
Research ToolsTrack hypotheses, findings, decisions over timeBetter scientific documentation
Project ManagementDecisions and context persist across team discussionsClearer history, faster onboarding

​
Memory Types

Memanto categorizes memories into 13 semantic types (like fact, preference, decision, goal, and instruction) to make memories highly organized and filterable. → See the Memory Types Reference for the complete list.

​
Architecture Overview

Memanto architecture

​
Deployment Options

  • Docker: Fastest setup, reproducible environments
  • Python: Development and customization
  • Cloud: AWS ECS, Google Cloud Run, Azure Container Instances
  • Local: Single machine testing and prototyping

​
Next Steps

Choose your path based on your use case:

​
Need Help?