CogniMemo Memory

Universal AI memory infrastructure that stores, understands, and learns from past interactions. Works across ChatGPT, Claude, Gemini, DeepSeek, and any AI mo...

Security Scan

The skill appears to do what it says (a memory SDK/demo) and does not request disproportionate access or install arbitrary code; the main inconsistency is that the README asks for an API key (COGNIMEMO_API_KEY) but the registry metadata does not declare it as a required credential.

Purpose & Capability

Name/description (universal AI memory) match the included materials: SKILL.md documents an API/SDK-based memory service and the code file is a local demo/mock implementation. The demo explicitly notes that a real 'cognimemo' package would be used in production, which aligns with the stated purpose.

Instruction Scope

SKILL.md stays within scope: it instructs obtaining an API key from cognimemo.com, installing SDKs, and using the memory API to store/search/update/delete memories. It does not direct the agent to read unrelated files, exfiltrate data, or call unexpected endpoints beyond the documented SDK/API usage.

Install Mechanism

There is no install spec in the registry (instruction-only). SKILL.md recommends installing the official pip/npm SDKs, which is proportional to the task. The included code file is a harmless mock/demo and does not download or execute remote archives.

Credentials

The SKILL.md instructs users to set COGNIMEMO_API_KEY (and the demo code reads that env var), but the skill metadata lists no required env vars or primary credential. Requesting an API key is appropriate for this service, but the registry metadata should declare it. No other unrelated secrets or config paths are requested.

Persistence & Privilege

The skill does not request 'always: true' or any elevated persistent presence. It contains no code that modifies other skills or system-wide agent settings. Autonomous invocation is allowed (platform default) but is not combined with other concerning flags.

Assessment

This skill is internally coherent and appears to be a demo + documentation for a memory SDK. Before installing: (1) confirm you trust cognimemo.com and the pip/npm packages the README names (verify package authors and versions), (2) be prepared to provide an API key (COGNIMEMO_API_KEY) and review the provider's privacy/security policy because cross-app persistent memory can store sensitive personal data, (3) note the included Python file is a local mock/demo and does not implement server-side storage — real behavior will depend on the external SDK/service, and (4) ask the publisher to update registry metadata to declare the API key env var so required credentials are explicit.

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