mcpField
A
Akasha Mcp Server

Akasha Mcp Server

Local
github.com/ocuilMemory & Knowledge4Updated 9w ago
Repository

About Akasha Mcp Server

Akasha MCP Server gives AI agents persistent memory shared across sessions and agents. It is for systems that need to retain and retrieve context, with layered memory and shared signals for coordination.

Key features

  1. 01Persistent shared memory
  2. 02Four cognitive memory layers
  3. 03Cross-memory search and recall
  4. 04Agent signal coordination
  5. 05Automatic memory consolidation

Use cases

  1. 01Save user preferences and project facts
  2. 02Retrieve API design or deployment notes
  3. 03Check other agents’ task status

MCP support

As an MCP server, it exposes memory read, write, and search tools, read-only resources, and prompt templates to clients.

#memory#knowledge#ai#agents#persistent-memory

Configuration

Local server config is the same for every client. Copy it into your client’s MCP config file.

mcp.json · Universal config
{
  "mcpServers": {
    "ocuil": {
      "command": "uvx",
      "args": [
        "git+https://github.com/ocuil/akasha-public#subdirectory"
      ],
      "env": {
        "AKASHA_API_URL": "<AKASHA_API_URL>"
      }
    }
  }
}
Run commanduvx 'git+https://github.com/ocuil/akasha-public#subdirectory'
Environment variables to set
AKASHA_API_URL

Local servers need a runtime on your machine (e.g. Node.js 18+). Config file locations differ by client; see your client’s docs.

Packages
pypigit+https://github.com/ocuil/akasha-public#subdirectory

Tools

No tool list yet

Local servers expose tools only once running on your machine, and the maintainer has not provided a tool list.

Details

From the project README

🧠 Akasha MCP Server

Give your AI agents persistent shared memory

MCP Python License Akasha

Your LLM forgets everything between conversations. Akasha fixes that.

The Problem

Every time you start a new conversation with Claude, Gemini, or GPT:

  • ❌ It doesn't remember what it learned yesterday
  • ❌ Multiple agents can't share knowledge
  • ❌ There's no persistent memory between sessions
  • ❌ You keep repeating the same context over and over

The Solution

Akasha gives your AI a persistent, shared memory — like giving it a brain that doesn't reset.

Claude ──┐                    ┌── "What did we decide about the API?"
Gemini ──┼── Akasha Memory ──┤── "Agent-B is already working on that"
GPT ─────┘                    └── "Here's what we learned last week"

What Can Your AI Do With Akasha?

ToolWhat it doesExample
akasha_writeSave anything to persistent memory"Remember that the user prefers Python over JS"
akasha_readRecall saved memories"What do we know about the API design?"
akasha_querySearch across all memories"Find everything related to deployment"
akasha_memory_storeWrite to cognitive layers (working/episodic/semantic/procedural)"Store this as a long-term fact"
akasha_memory_recallRecall from a specific layer"What procedures do we have for deployments?"
akasha_pheromone_emitSignal other agents (stigmergy)"Mark this task as in-progress"
akasha_pheromone_senseSense what other agents are doing"Is anyone else working on the API?"
akasha_healthCheck system status"Is the memory system healthy?"
akasha_diagnosticsFull cluster health assessment"Run a full diagnostic report"
akasha_agentsList all connected agents"Who else is online?"

Quick Setup (2 minutes)

1. Start Akasha
docker run -d --name akasha -p 7777:7777 -p 50051:50051 alejandrosl/akasha:latest
2. Get an API Key
# Login
TOKEN=$(curl -sk -X POST https://localhost:7777/api/v1/auth/login \
  -H 'Content-Type: application/json' \
  -d '{"username":"akasha","password":"akasha"}' | jq -r .token)

# Create API key
curl -sk -X POST https://localhost:7777/api/v1/admin/keys \
  -H "Authorization: Bearer $TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"name":"mcp-server","namespaces":["**"],"role":"agent"}' | jq .key
3. Connect to Your AI
Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "akasha": {
      "command": "uvx",
      "args": ["--from", "git+https://github.com/ocuil/akasha-public#subdirectory=mcp-server", "akasha-mcp"],
      "env": {
        "AKASHA_URL": "https://localhost:7777",
        "AKASHA_API_KEY": "ak_your_key_here"
      }
    }
  }
}
Cursor

Add to .cursor/mcp.json:

{
  "mcpServers": {
    "akasha": {
      "command": "uvx",
      "args": ["--from", "git+https://github.com/ocuil/akasha-public#subdirectory=mcp-server", "akasha-mcp"],
      "env": {
        "AKASHA_URL": "https://localhost:7777",
        "AKASHA_API_KEY": "ak_your_key_here"
      }
    }
  }
}
Manual (pip install) 
pip install git+https://github.com/ocuil/akasha-public#subdirectory=mcp-server

# Run
AKASHA_URL=https://localhost:7777 \
AKASHA_API_KEY=ak_your_key_here \
akasha-mcp

What Makes Akasha Different?

🐜 Stigmergy — Agents Coordinate Without Talking

Inspired by how ant colonies build complex structures without a blueprint:

Agent A writes: "task/enrichment → SUCCESS (quality: 0.95)"
Agent B reads:  "Someone already did enrichment with 95% quality — skip it"
Agent C reads:  "Two successes on enrichment — this is a reliable path"

No message queues, no APIs between agents. Just shared traces in the environment.

🧠 Four Layers of Memory
LayerPurposeLifespan
WorkingCurrent task scratchpadMinutes
EpisodicWhat happened — events, outcomesHours → Days
SemanticWhat we know — facts, patternsDays → Permanent
ProceduralHow to do things — workflowsPermanent
🧘 Nidra — Automatic Memory Consolidation

Like human sleep, Akasha's background engine:

  • Cleans up stale working memory
  • Consolidates repeated patterns into long-term knowledge
  • Evaporates decayed signals automatically

Resources & Prompts

Resources (Read-Only Context)
URIDescription
akasha://healthCluster health status
akasha://memory/layersMemory layer distribution
akasha://records/{path}Read any record by path
akasha://agents/{agent_id}Agent state
akasha://treeFull tree of all paths
akasha://diagnosticsCluster diagnostic report
Prompt Templates
PromptWhat it does
memory_consolidationAnalyze and consolidate episodic memories into semantic knowledge
agent_status_reportFull system-wide agent & cluster status
system_health_checkDeep cluster health diagnostic
knowledge_extractionExtract and organize knowledge on any topic

Configuration

VariableDefaultDescription
AKASHA_URLhttps://localhost:7777Akasha server endpoint
AKASHA_API_KEY(required)API key for authentication
AKASHA_VERIFY_SSLfalseVerify TLS certificates

Development

# Clone
git clone https://github.com/ocuil/akasha-public
cd akasha-public/mcp-server

# Install in dev mode
pip install -e .

# Interactive MCP inspector
fastmcp dev server.py

# Run with SSE transport
python server.py --transport sse --port 8765

Learn More

Built with FastMCP · Powered by Akasha

"Give your AI a memory that persists — across conversations, across agents, across time."

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.