CogniMemo - Universal AI Memory

CogniMemo provides persistent, intelligent memory for AI applications. Unlike session-based memory that disappears, CogniMemo stores, understands, and learns from interactions over time.

Why CogniMemo?

• Cross-app memory - Same memory across ChatGPT, Claude, Gemini, DeepSeek
• Model-agnostic - Works with OpenAI, Anthropic, Gemini, Mistral, Ollama
• Auto-captured - Decides what matters, no manual organization
• Permission-based - Users control what each app can access
• Simple API - REST API, SDKs, LangChain adapters

How It Works

1. Memory Auto-Captured

CogniMemo captures from: - Chat conversations - Documents and links - Tasks, decisions, notes - User actions

2. AI Understands Context

Extracts: - Entities (people, places, things) - Relationships - Patterns and habits - Temporal context

3. Permission-Based Access

• Apps see only approved memory types
• Users can revoke access anytime
• Scoped by permission level

Quick Start

Step 1: Get API Key

1. Go to https://cognimemo.com
2. Create account
3. Generate API key from dashboard
4. Add to environment:

COGNIMEMO_API_KEY=your-api-key-here

Step 2: Install SDK

# Python
pip install cognimemo

# Node.js
npm install @cognimemo/sdk

Step 3: Initialize Client

from cognimemo import CogniMemo

# Initialize with API key
memory = CogniMemo(api_key="your-api-key")

# Or from environment
memory = CogniMemo()  # Uses COGNIMEMO_API_KEY

Core Operations

Store Memory

# Store a conversation
memory.store(
    user_id="user-123",
    content="User prefers Portuguese language responses",
    metadata={
        "type": "preference",
        "source": "chat",
        "confidence": 0.9
    }
)

# Store a decision
memory.store(
    user_id="user-123",
    content="Decided to use React for the frontend project",
    metadata={
        "type": "decision",
        "project": "web-app",
        "timestamp": "2026-03-16"
    }
)

# Store a task
memory.store(
    user_id="user-123",
    content="Need to prepare quarterly report by Friday",
    metadata={
        "type": "task",
        "deadline": "2026-03-20",
        "priority": "high"
    }
)

Retrieve Memory

# Semantic search
results = memory.search(
    user_id="user-123",
    query="What are the user's preferences?",
    limit=10
)

# Get specific type
preferences = memory.get_by_type(
    user_id="user-123",
    memory_type="preference"
)

# Get recent
recent = memory.get_recent(
    user_id="user-123",
    hours=24
)

Update Memory

# Update existing memory
memory.update(
    memory_id="mem-456",
    content="User prefers concise Portuguese responses",
    metadata={"confidence": 1.0}
)

# Add context to existing memory
memory.append(
    memory_id="mem-456",
    additional_context="Also prefers bullet points over paragraphs"
)

Delete Memory

# Delete specific memory
memory.delete(memory_id="mem-456")

# Clear all memories for a user
memory.clear(user_id="user-123")

# Clear by type
memory.clear(user_id="user-123", memory_type="task")

Memory Types

Type	Description	Example
preference	User preferences	"Prefers dark mode"
decision	Decisions made	"Chose PostgreSQL for database"
task	Tasks to remember	"Finish report by Friday"
fact	Factual information	"Works at Acme Corp"
context	Session context	"Currently working on API integration"
pattern	Behavioral patterns	"Usually works late on Tuesdays"

Permission Scopes

# Request specific permissions
auth_url = memory.get_auth_url(
    scopes=["preferences", "decisions", "tasks"],
    redirect_uri="https://your-app.com/callback"
)

# Check user permissions
permissions = memory.get_permissions(user_id="user-123")
# Returns: {"preferences": True, "decisions": True, "tasks": False}

Integration with AI Models

OpenAI / ChatGPT

import openai
from cognimemo import CogniMemo

memory = CogniMemo()
user_id = "user-123"

# Get relevant context
context = memory.search(
    user_id=user_id,
    query="User preferences and recent decisions",
    limit=5
)

# Build prompt with memory
messages = [
    {"role": "system", "content": f"Context: {context}"},
    {"role": "user", "content": "Help me with my project"}
]

response = openai.chat.completions.create(
    model="gpt-4",
    messages=messages
)

# Store important info from conversation
memory.store(
    user_id=user_id,
    content="User asked about React component library",
    metadata={"type": "context", "session": "current"}
)

Anthropic / Claude

import anthropic
from cognimemo import CogniMemo

memory = CogniMemo()
user_id = "user-123"

# Get memory context
context = memory.search(
    user_id=user_id,
    query="User preferences",
    limit=10
)

client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    system=f"Remember: {context}",
    messages=[{"role": "user", "content": "What should I work on?"}]
)

LangChain Integration

from langchain.memory import CogniMemoMemory
from langchain.chains import ConversationChain
from langchain.llms import OpenAI

# Use CogniMemo as LangChain memory
memory = CogniMemoMemory(
    api_key="your-api-key",
    user_id="user-123"
)

chain = ConversationChain(
    llm=OpenAI(),
    memory=memory
)

# Memory automatically stored and retrieved
response = chain.predict(input="What did we discuss last time?")

OpenClaw Integration

# In OpenClaw skill or agent
from cognimemo import CogniMemo

class CogniMemoTool:
    """Tool for OpenClaw agents to access persistent memory."""

    def __init__(self, user_id: str):
        self.memory = CogniMemo()
        self.user_id = user_id

    def remember(self, content: str, memory_type: str = "context"):
        """Store something in memory."""
        self.memory.store(
            user_id=self.user_id,
            content=content,
            metadata={"type": memory_type}
        )
        return f"Remembered: {content}"

    def recall(self, query: str):
        """Search memory for relevant information."""
        results = self.memory.search(
            user_id=self.user_id,
            query=query,
            limit=10
        )
        return results

    def get_preferences(self):
        """Get user preferences."""
        return self.memory.get_by_type(
            user_id=self.user_id,
            memory_type="preference"
        )

Storage Backends

CogniMemo supports multiple storage layers:

Backend	Best For
Pinecone	Vector similarity search
Weaviate	Hybrid search
PostgreSQL	Relational queries
Redis	Fast retrieval

Configure via environment:

COGNIMEMO_STORAGE=pinecone  # or weaviate, postgres, redis
COGNIMEMO_PINECONE_API_KEY=your-key
COGNIMEMO_PINECONE_ENV=us-west1-gcp

Best Practices

1. Store Wisely

# Good: Specific, structured memory
memory.store(
    user_id="user-123",
    content="User prefers dark mode in code editors",
    metadata={"type": "preference", "category": "ui"}
)

# Bad: Vague, unstructured
memory.store(user_id="user-123", content="user likes stuff")

2. Search Effectively

# Use semantic queries
results = memory.search(
    user_id="user-123",
    query="What editor preferences does the user have?",
    limit=5
)

3. Respect Privacy

# Check permissions before storing
if memory.has_permission(user_id, "preferences"):
    memory.store(...)

Pricing

• Free Tier: 1,000 memories/month
• Pro: $29/month for 50,000 memories
• Enterprise: Custom pricing for unlimited

Resources

• Website: https://cognimemo.com
• Documentation: https://docs.cognimemo.com
• API Reference: https://api.cognimemo.com/docs
• GitHub: https://github.com/cognimemo/sdk

Error Handling

from cognimemo import CogniMemo, CogniMemoError

try:
    memory.store(user_id="user-123", content="Important info")
except CogniMemoError as e:
    if e.code == "quota_exceeded":
        print("Free tier limit reached. Upgrade at cognimemo.com/pricing")
    elif e.code == "permission_denied":
        print("User has not granted permission for this memory type")
    else:
        raise