hippocampus-mcp is a personal memory MCP server that ingests conversation logs from multiple AI platforms (Claude Code, ChatGPT, claude.ai, Codex CLI) into a local PostgreSQL database and exposes them via MCP tools for searching, listing, and retrieving past conversations, plus an optional cross-project agent memory layer.
search_personal_memory — Semantic/hybrid search across personal conversation history using vector embeddings (requires BGE-M3 or similar embedding backend).
get_conversation — Retrieve the full transcript of a specific conversation by ID.
list_recent_conversations — List conversations ordered by recency, with optional filters for time window, platform (claude_code, chatgpt, etc.), and project name.
list_project_conversations — List recent conversations scoped to a specific project or workspace via case-insensitive substring match.
get_conversation_summary — Get compact metadata and a bounded excerpt (title, platform, dates, message count, topic) without loading the full transcript.
search_ghost_memory — Search the cross-project agent memory vault (accumulated rules, feedback, lessons learned) using hybrid full-text + vector ranking, with optional project scoping. An empty query returns a ranked overview.
Additional capabilities:
Incremental, deduplicated ingestion — re-running ingest is safe and only adds new conversations.
Summarization via hippocampus summarize builds rollup summaries for long conversations (requires Anthropic API key).
All data is stored locally in a user-controlled PostgreSQL database, with no external data sharing unless explicitly opted into.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@hippocampus-mcp find our postgres deadlock discussion from last month"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
English ・ 日本語
Personal memory infrastructure for people who use AI agents every day.
hippocampus-mcp ingests your conversation logs from multiple platforms (Claude Code, ChatGPT, claude.ai, Codex, Grok, Kimi, Antigravity) into a PostgreSQL + pgvector database that you run, and exposes them as MCP search tools to any agent session. Your past reasoning, decisions, and debugging sessions stop evaporating when the window closes.
The differentiator is the ghost layer: a separate, opt-in vault where the agent's own accumulated rules and feedback ("last time this failed because...") are synced nightly and become searchable from every project — cross-project agent memory, not just human conversation recall.
On top of the searchable corpus sit three further opt-in layers, each with
its own doc: a distilled facts layer (search_facts), a first-person
diary the agent writes once a day (plus a read-only grounding auditor that
checks each entry's self-criticism against the transcripts), and an editable,
human-gated wiki for the subject knowledge you actually study. See
docs/ARCHITECTURE.md for how the pieces fit.
The corpus is reachable not only from terminal agents but, via an opt-in OAuth-gated remote MCP connector, from claude.ai on the web and mobile too — ask claude.ai on your phone "what did I decide about X?" and it searches your database. See docs/CONNECTOR.md.
The name: the hippocampus is the brain structure that consolidates short-term experience into long-term memory during sleep. This system imitates that loop — daytime sessions accumulate as JSONL, a nightly ingest embeds and persists them, and the next session can recall them.
INGEST STORE RETRIEVE (MCP)
Claude Code sessions ─┐
ChatGPT export ZIP ─┤ parse → scrub → embed personal.* ──┐ search_personal_memory
claude.ai export ZIP ─┼─────────────────────────▶ (your ├─ search_conversations
Codex CLI history ─┘ PostgreSQL) ├─ list_recent_conversations
┘ get_conversation ...
agent memory files ─── nightly dub (opt-in) ─▶ agent.* ──── search_ghost_memoryPrerequisites: Python 3.11+, a psql client on PATH (Debian/Ubuntu:
apt-get install postgresql-client), and either Docker or an existing
PostgreSQL with the pgvector extension.
Everything runs on your machine by default — the database is a bundled
docker-compose postgres, and hippocampus init sets it up for you.
git clone <this-repo> hippocampus-mcp && cd hippocampus-mcp
# 1. Install the package
pip install .
# 2. First-run setup. Pick "local" for the database (the default), pick an
# embed backend, optionally provision the ghost layer. init generates
# the DB password, writes .env (mode 0600), starts the compose postgres,
# runs migrations, and prints the MCP registration snippet.
hippocampus init
# 3. For local semantic search without resident BGE RAM:
# choose "bge-ondemand" in init. The first semantic ingest/search starts
# the compose BGE-M3 server; it exits after the idle timeout.
# 4. Verify, then ingest your Claude Code sessions
hippocampus doctor
hippocampus ingest claude-codeNon-interactive minimal install (no embed model — semantic tools stay hidden, and ingest refuses to run, until a backend is configured; vectors are written together with the text, never backfilled silently):
hippocampus init --yes --embed noneIf host port 5432 is taken (a host postgres, or a Windows-side listener
under WSL2), pass --pg-port <free-port> — compose and the generated
PG_URL follow it via .env.
Running the database on a separate server instead? Choose existing
at the database prompt (or --db existing) and paste your PostgreSQL
URL — see INSTALL.md Path B, and PRIVACY.md for what a remote database
implies (your conversation text transits the network; keep it on a
private network or behind TLS). Local is the recommended default.
Add to ~/.claude/settings.json (or your client's MCP config). The
snippet contains no secrets — the server reads .env from its working
directory:
{
"mcpServers": {
"hippocampus": {
"command": "/path/to/your/venv/bin/hippocampus-mcp"
}
}
}If your MCP client does not launch servers from the project directory,
use the one-line cd && exec wrapper that hippocampus init prints at
the end of its run.
Then, from a fresh agent session:
search_personal_memory("that postgres deadlock we debugged")
list_recent_conversations(days=2)
get_conversation("claude_code:<conv-id>")
search_ghost_memory(current_project="my-repo") # ghost layer, if enabledRelated MCP server: mesh-memory
Seven sources are built in (hippocampus ingest --list):
Source | Command | Input |
Claude Code |
| auto-discovers |
ChatGPT |
| official data-export ZIP |
claude.ai |
| official data-export ZIP |
Codex CLI |
|
|
Antigravity |
|
|
Kimi Code |
|
|
Grok CLI |
|
|
Every source runs the same pipeline: parse → credential scrub → embed → upsert → verify (the run fails loudly if any ingested message ended up without a vector). Conversations are deduplicated, so re-running an ingest is safe.
After ingest, hippocampus summarize builds per-conversation rollup
summaries and segment summaries for long conversations (substrate for
summary-level search). It requires an Anthropic API key
(ANTHROPIC_API_KEY) and a working embed backend — see
PRIVACY.md for exactly what text it sends where.
Semantic (vector) search is off until you explicitly choose a
backend — there is no silent model download. Three choices at
hippocampus init (changeable later in .env):
Choice | What it means | Cost |
| keyword/recency tools only; semantic tools are hidden | zero |
| local compose BGE-M3 starts on first semantic ingest/search, then exits after | ~6 GB RAM only while the container is running; first request waits for startup/download |
| BGE-M3 over HTTP — | ~6 GB RAM in the container while it is running |
| model loaded inside the server process ( | ~6 GB RAM in-process, ~6 GB one-time download |
Recommended single-machine setup:
hippocampus init --embed bge-ondemand
hippocampus doctor # reports cold/hot status without starting BGE
hippocampus ingest codex # first semantic call starts compose `bge`Peak memory is unchanged: BGE-M3 still needs roughly 6 GB while it is running. On-demand only reduces how long that memory stays resident.
Manual low-memory workflow for a single local machine: keep bge-http
configured, start the semantic backend only when you need it, then stop it
to release the BGE-M3 container memory:
docker compose --profile bge up -d # start semantic backend
hippocampus doctor
hippocampus ingest claude-code # or run semantic search/summarize
docker compose stop bge # release BGE-M3 memoryIf BGE_EMBED_URL remains set while the local bge container is stopped,
semantic ingest/search fails loudly until you start it again. That is
expected for manual low-memory use; run docker compose --profile bge up -d
before semantic work.
On the first bge start, the model downloads into the compose hf_cache
volume (mounted as /hf_cache in the container). If the first download is
interrupted and later starts keep failing during model load, stop bge and
retry. If the HuggingFace cache is corrupt, remove only the compose
hf_cache volume and let it re-download; do not remove pg_data, which is
the database volume.
Details and a decision table: INSTALL.md. Code-level
bge-ondemand behavior is documented in docs/BGE_ONDEMAND.md.
Project-local agent memory files can be promoted — via an explicit
dual-signal opt-in (frontmatter scope: shared and a line in a
human-edited allowlist file) — into a shared vault that any project's
session can search through search_ghost_memory. Promotion is
default-deny; a content scanner is a third wall behind the two signals.
hippocampus init --ghost provisions the read-only database role it
needs. Full user guide: docs/GHOST_LAYER_USER.md.
The stdio MCP server only reaches terminal agents. To search your memory from
claude.ai's web app or phone app, run the optional connector: a second
entry point (hippocampus-mcp-connector-oauth) that serves the same tools over
streamable HTTP behind a single-owner OAuth authorization server, exposed
through a cloudflared tunnel.
It is deliberately narrower than the stdio surface — a fail-closed read-only allowlist (personal/conversation/library search only; ghost, facts, and full-thread retrieval are excluded), audience-bound tokens, a chain-read budget, and fail-open read auditing. Register it once in claude.ai's connector settings and it works from every device.
Setup, security posture, and troubleshooting: docs/CONNECTOR.md.
Short version: your full conversation text and its vectors live in your PostgreSQL. Nothing leaves your machine unless you explicitly enable a feature that needs it (Anthropic-backed scoring/summaries, a remote embed endpoint). Credential scrubbing at ingest is best-effort, not a guarantee. Read PRIVACY.md before ingesting anything sensitive.
This is published as useful infrastructure, not a supported product.
It is the actual daily-driver memory system of its author, extracted into
an installable shape. Issues and PRs are welcome and handled best-effort;
there is no SLA, no roadmap commitments, and APIs may change between
minor versions. If it breaks, hippocampus doctor output (which is
designed to be safe to paste — no secrets ever appear in it) is the most
useful thing to include in a report.
INSTALL.md — detailed setup: compose vs existing PG, embed backends, migrations, troubleshooting, automation
PRIVACY.md — what is stored, what leaves the box and when, scrub limits, prompt-injection posture
docs/GHOST_LAYER_USER.md — ghost layer user guide
docs/CONNECTOR.md — claude.ai remote MCP connector (use your memory from web & mobile)
docs/SECRETS_HARDENED.md — optional sops-encrypted secrets setup (default is a plain .env, mode 0600)
docs/CONFIG.md — full environment-variable reference
Get full conversation thread by conv_id. Searches personal memory first, then library.
| Name | Required | Description | Default |
|---|---|---|---|
| conv_id | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description solely informs behavior. It discloses search order (personal memory then library) but omits other traits like idempotency, error handling, or what happens if conv_id is not found.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with 12 words, no filler. Action verb first, efficient and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given low complexity and presence of output schema, description covers basic operation but misses detail like uniqueness or encoding of conv_id. Gaps remain due to no annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, yet description only restates 'by conv_id' without adding format, examples, or constraints. The parameter meaning is only trivially extended.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves a full conversation thread using a conv_id, and specifies a two-step search order. However, it does not explicitly differentiate from sibling tools like get_conversation_summary.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use (need full thread by ID) and provides search order, but lacks explicit when-not-to-use scenarios or direct comparison to alternatives like list_recent_conversations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get conversation metadata and a compact bounded excerpt without the full transcript.
Returns title, platform, dates, msg_count, topic/cluster, and up to max_messages messages sampled from the start and end of the conversation.
Args: conv_id: conversation ID (from search_personal_memory or list_recent_conversations) max_messages: max messages to include; split between first half and last half (default 12)
| Name | Required | Description | Default |
|---|---|---|---|
| conv_id | Yes | ||
| max_messages | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations, so description bears full burden. Describes read-like operation and return fields, but does not explicitly state it's read-only or discuss error cases, rate limits, or side effects. Adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Concise two paragraphs, first summarizing purpose and return fields, second listing args. No unnecessary words. Could be more structured but effective.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers return fields, args, and usage context. Output schema exists, so return details are fine. Missing info on limits or error handling, but sufficient for typical use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has zero description coverage, so description must compensate. It adds meaning to conv_id (source) and max_messages (split between start and end, default 12). This goes beyond schema information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it gets metadata and a bounded excerpt, not full transcript, distinguishing from get_conversation. The verb 'Get' and resource 'conversation summary' are specific.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides when to use (compact excerpt without full transcript) and where to get conv_id (search_personal_memory, list_recent_conversations). Lacks explicit when-not-to-use but contrast with siblings is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read the agent's daily first-person diary from the diary layer.
The diary is a distinct layer (personal.diary): one LLM-written entry per day reflecting on that day's work — not part of the conversation corpus, so search_personal_memory does NOT surface it. Use this to read the diary itself.
Args: date: 'latest' for the most recent entries, or 'YYYY-MM-DD' for a specific day. n: when date='latest', how many recent entries to return (default 1, max 14).
| Name | Required | Description | Default |
|---|---|---|---|
| n | No | ||
| date | No | latest |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It describes the diary layer, entry frequency, and return behavior. Lacks explicit statement about non-destructiveness, but context implies read-only. Minor gap for full transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Highly concise: one sentence states purpose, paragraph explains distinct layer, then Args section. No fluff, front-loaded with key info.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given two parameters and existence of output schema, description fully covers tool's behavior, usage, and parameters. Sibling tools are distinct, so no missing context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but description adds full meaning: date values ('latest' or YYYY-MM-DD), n meaning (number of recent entries when date='latest', default 1, max 14). Complements schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it reads the agent's daily first-person diary, distinguishing it from conversation tools by noting the diary is a separate layer not surfaced by search_personal_memory.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly explains when to use (to read the diary itself) and when not (since search_personal_memory does not surface it). Arg section details parameter usage: date as 'latest' or specific day, n for count with max 14.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return recent conversations scoped to a project or workspace.
Matches on conversation title (case-insensitive substring). Covers cases like "my-webapp", "JSAS2026", "personal/memory/mcp", etc.
Args: project: substring to match against conversation title days: look-back window in days (default 14) limit: max conversations to return (default 30)
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | ||
| limit | No | ||
| project | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses substring matching and parameters but omits ordering, pagination, or whether conversations are read-only. Some key behavioral aspects are missing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, with a one-line purpose, brief matching detail, and a clean args list. Every sentence adds value, and the structure is logically front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the existence of an output schema (not detailed here), the description adequately covers the tool's function, matching logic, and parameters. Minor gaps like missing ordering or error handling are acceptable for a list tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description compensates by explaining each parameter: project as substring, days as look-back window, limit as max count. It adds meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool 'returns recent conversations scoped to a project or workspace' with substring matching on title. It distinguishes from sibling tools like 'list_recent_conversations' by emphasizing project/workspace scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use (to find conversations by project substring) but does not explicitly state when not to use or compare with alternatives. The sibling tools are not referenced, leaving the agent to infer context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return conversations ordered by recency (not semantic similarity).
Use this when the user asks for "recent conversations", "ここ2日の会話", etc. Each row header: [conv_id | platform | started→ended | title | topic | cluster | msgs | intensity] followed by a short snippet of the first message.
Args: days: look-back window in days (default 2) limit: max conversations to return (default 20) platform: filter by platform (e.g. "claude_code", "chatgpt") project: substring match on conversation title (e.g. "my-webapp", "JSAS2026")
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | ||
| limit | No | ||
| project | No | ||
| platform | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the ordering (recency), output format (row headers with fields), and parameters. However, with no annotations provided, it does not fully disclose behavioral traits such as whether this is a read-only operation, any rate limits, or error handling. For a read tool, this is adequate but not comprehensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: a one-sentence summary of purpose, usage guidance, output format preview, and a bullet list of parameters with defaults and examples. Every sentence serves a purpose, and key information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that an output schema exists, the description is fairly complete: it covers purpose, usage cues, parameter details, and output format. It does not discuss potential edge cases (e.g., no results, maximum days) or error handling, but these are minor gaps for a simple list tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description carries the full burden for parameter meaning. It provides clear explanations for all four parameters: 'days' (look-back window, default 2), 'limit' (max conversations, default 20), 'platform' (filter with examples), and 'project' (substring match with examples). This adds significant value beyond the schema alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool returns conversations ordered by recency, not semantic similarity. It provides a specific verb ('Return') and a resource ('conversations'), and implicitly distinguishes from sibling tools like search_ghost_memory by clarifying it is not semantic search. However, it does not explicitly differentiate from other list tools like list_project_conversations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly advises when to use the tool: 'Use this when the user asks for recent conversations...' with examples including Japanese phrases. It does not specify when not to use it or mention alternatives, but provides clear context for its intended use case.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search cross-project agent ghost memories (= this agent's rule/feedback accumulation).
Empty query → list top-ranked memories (= "what's in my ghost vault" overview). Non-empty query → hybrid FTS + vector semantic ranking via agent.search_ghost_ranked (SECURITY DEFINER, migration 020).
⚠️ current_project is caller-attested, NOT server-verified. shared-restricted requires current_project in per-memory allowlist (= pentest/commercial boundary).
Ranking: rank_score = base_score * recency_factor + semantic_sim * 0.5 base_score = 0.2activation + 0.5incident_prevention + 0.3endorsement - 0.4correction - 0.2pred_error + 0.1scope_bonus recency_factor = exp(-days_since_last_activated / 30) semantic_sim = 1 - cosine_distance(query_vec, memory.dense) (0 if empty query)
Each returned row triggers agent.bump_activation, so memories that surface in search naturally rise in rank over time (= self-tuning loop).
| Name | Required | Description | Default |
|---|---|---|---|
| query | No | ||
| n_results | No | ||
| expand_links | No | ||
| current_project | No | ||
| include_restricted | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses ranking formula, the self-tuning loop via bump_activation (side effect), and security details about SECURITY DEFINER and shared-restricted allowlist. This is comprehensive behavioral disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Well-structured with clear sections: purpose, security warning, ranking formula, side effect. Front-loaded core usage. However, the ranking formula is detailed and may be more than necessary for an agent to select/invoke the tool correctly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 5 parameters and no schema descriptions, the description covers overall behavior, ranking, side effect, and security. But missing explanations for n_results, expand_links, and include_restricted limit completeness. Output schema exists, so return values are not needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so description must explain all 5 parameters. It only explains the query parameter (empty vs. non-empty) and implicitly current_project via security warning. n_results, expand_links, and include_restricted are not described. The ranking formula is given but not tied to parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the tool searches cross-project agent ghost memories, differentiating empty query (list top-ranked) from non-empty query (hybrid search). The verb 'search' and resource 'ghost memory' are specific, and sibling tools (conversations/diaries) are distinct.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides context for empty vs. non-empty query usage and security caveats about current_project not being server-verified. Lacks explicit alternatives among siblings, but the purpose is so distinct that siblings are clearly different.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v2.2.0get_diarysearch_ghost_memory1 field changedInput schema / properties / expand_linksAdded value: +{
+ "default": true,
+ "title": "Expand Links",
+ "type": "boolean"
+}v0.1.0get_conversationget_conversation_summarylist_project_conversationslist_recent_conversationssearch_ghost_memoryEach tool targets a distinct aspect of memory retrieval: full conversation, summary, diary, project-scoped conversations, recent conversations, and ghost memories. No overlap in purpose.
All tools follow a consistent 'verb_noun' pattern with underscores: get_conversation, get_conversation_summary, get_diary, list_project_conversations, list_recent_conversations, search_ghost_memory. Verbs are indicative of the operation.
With 6 tools, the server covers the core memory retrieval operations without being bloated. Each tool serves a clear need within the domain of personal memory access.
The tool set provides multiple ways to retrieve conversations, diary entries, and ghost memories. A minor gap is the lack of semantic search across conversations themselves, but the existing tools cover primary use cases.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Persistent memory for AI agents — log and recall conversation context over MCP.
Persistent memory for AI agents across Claude, ChatGPT and any MCP client.
Analytical memory for AI agents: a real Postgres queried in plain English over MCP. One command.
Persistent, inspectable memory for AI agents with lineage, correction, and a hosted MCP endpoint.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/hrmtz/hippocampus'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
