Skip to main content
Glama
akaiserg

MCP Memory Tracker

by akaiserg
OverviewSchemaRelated ServersScoreDiscussions
Python

MCP Memory Tracker

A Model Context Protocol (MCP) server that provides persistent memory capabilities using OpenAI's vector stores. This allows AI assistants to save and search through memories across conversations.

Features

  • Save Memories: Store text-based memories in OpenAI vector stores

  • Search Memories: Semantic search through saved memories using natural language queries

  • Persistent Storage: Memories are stored in OpenAI's cloud infrastructure

  • MCP Compatible: Works with any MCP-compatible client (like Claude Desktop)

Related MCP server: Mem0 MCP Server

Prerequisites

  • Python 3.8+

  • OpenAI API key

  • UV package manager (recommended) or pip

Installation

  1. Clone the repository:

git clone <repository-url>
cd mcp-memory-tracker

  1. Install dependencies:

# Using UV (recommended)
uv sync

# Or using pip
pip install -r requirements.txt

  1. Set up environment variables: Create a .env file in the project root:

OPENAI_API_KEY=your_openai_api_key_here

Usage

Running the MCP Server

# Using UV
uv run server.py

# Or using Python directly
python server.py

Available Tools

save_memory(memory: str)

Saves a text memory to the vector store.

Parameters:

  • memory (string): The text content to save

Returns:

{
  "status": "saved",
  "vector store id": "vs_xxxxx"
}

Example:

save_memory("I met John at the coffee shop on Main Street. He's a software engineer who loves hiking.")

search_memories(query: str)

Searches through saved memories using semantic search.

Parameters:

  • query (string): Natural language search query

Returns:

{
  "status": "success",
  "results": ["matching memory content..."]
}

Example:

search_memories("Who did I meet at the coffee shop?")

Integration with MCP Clients

Claude Desktop

Add this server to your Claude Desktop configuration:

{
  "mcpServers": {
    "memory-tracker": {
      "command": "uv",
      "args": ["run", "/path/to/mcp-memory-tracker/server.py"],
      "env": {
        "OPENAI_API_KEY": "your_api_key_here"
      }
    }
  }
}

Other MCP Clients

This server implements the standard MCP protocol and should work with any compatible client. Refer to your client's documentation for configuration details.

How It Works

  1. Vector Store Management: The server automatically creates and manages an OpenAI vector store named "memories"

  2. Memory Storage: When you save a memory, it's uploaded as a text file to the vector store

  3. Semantic Search: The search functionality uses OpenAI's vector search capabilities to find relevant memories based on meaning, not just keywords

Configuration

The server uses the following constants that can be modified in server.py:

  • VECTOR_STORE_NAME: Name of the OpenAI vector store (default: "memories")

Dependencies

  • fastmcp: MCP server framework

  • openai: OpenAI Python SDK

  • python-dotenv: Environment variable management

Troubleshooting

Common Issues

  1. "OPENAI_API_KEY not found": Make sure your .env file is properly configured

  2. "'SyncPage' object has no attribute...": This indicates an API response structure issue - check your OpenAI SDK version

  3. File upload errors: Ensure your OpenAI API key has vector store permissions

Debug Mode

Add print statements to see detailed responses:

print(f"Vector store ID: {vector_store.id}")
print(f"Search results: {results}")

Contributing

  1. Fork the repository

  2. Create a feature branch

  3. Make your changes

  4. Submit a pull request

License

[Add your license here]

Support

For issues and questions:

Available Tools

2 tools
save_memoryC

Save a memory to the vector store.

ParametersJSON Schema
NameRequiredDescriptionDefault
memoryYes

TDQS

C2.8/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action is to 'Save' but doesn't mention whether this is a write operation, what permissions are needed, if it's idempotent, or what happens on success/failure. For a mutation tool with zero annotation coverage, this leaves significant behavioral gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise with a single sentence that directly states the tool's purpose. There's no wasted language or unnecessary elaboration, making it efficiently front-loaded and easy to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given this is a mutation tool with no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It doesn't address behavioral aspects like side effects, error conditions, or return values, leaving the agent with insufficient context for reliable invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate for the undocumented parameter. It mentions 'memory' but doesn't explain what constitutes a valid memory, its format, length constraints, or how it's stored. The description adds minimal semantic value beyond the parameter name itself.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Save') and target resource ('a memory to the vector store'), providing a specific verb+resource combination. However, it doesn't differentiate from its sibling 'search_memories' beyond the obvious action difference, so it doesn't fully distinguish from alternatives.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus its sibling 'search_memories' or any other alternatives. It lacks context about prerequisites, appropriate scenarios, or exclusions, leaving the agent with minimal usage direction.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_memoriesC

Search the vector store for memories that match the query.

ParametersJSON Schema
NameRequiredDescriptionDefault
queryYes

TDQS

C2.8/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It mentions searching a 'vector store' which hints at semantic matching, but doesn't disclose details like return format, pagination, error handling, or performance characteristics.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no annotations, no output schema, and low schema coverage, the description is incomplete. It lacks details on behavior, parameters, and expected results, making it inadequate for a tool that performs a non-trivial search operation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate but adds little. It mentions 'query' but doesn't explain what constitutes a valid query (e.g., keywords, natural language), its format, or how matching works, leaving parameter meaning unclear.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Search') and resource ('vector store for memories'), making the purpose understandable. It doesn't explicitly distinguish from the sibling 'save_memory', but the verb 'Search' versus 'save' provides implicit differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives or in what context. It mentions 'match the query' but doesn't specify scenarios, prerequisites, or exclusions, leaving usage ambiguous.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. 2 tool updatesv1.0.0
    • Changedsave_memory1 field changed
      • addedInput schema / title
        Added value: +"save_memoryArguments"
    • Changedsearch_memories1 field changed
      • addedInput schema / title
        Added value: +"search_memoriesArguments"
  2. 2 tool updates
    • First observedsave_memory
    • First observedsearch_memories
Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3/5.0
Disambiguation5/5

The two tools have clearly distinct purposes: one saves memories and the other searches memories. There is no overlap or ambiguity between these operations, making it easy for an agent to select the correct tool based on the intended action.

Naming Consistency5/5

Both tools follow a consistent verb_noun pattern (save_memory, search_memories) with clear, descriptive verbs. The naming is uniform and predictable, adhering to snake_case throughout without any deviations.

Tool Count2/5

With only two tools, the server feels thin for a memory tracker domain. While save and search are core operations, typical memory systems might also include update, delete, list, or clear functions. The count is too low for comprehensive coverage, limiting agent capabilities.

Completeness2/5

The tool surface is significantly incomplete for a memory tracker. It lacks essential operations like updating or deleting memories, listing all memories, or managing memory categories. This creates dead ends for agents trying to perform full lifecycle management of memories.

Maintenance

ActivityInactive
ResponsivenessNo issues

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

  • Mem0 MCP Server

    ryaker
    A
    license
    Not graded
    quality
    C
    maintenance
    A Model Context Protocol server that integrates AI assistants with Mem0.ai's persistent memory system, allowing models to store, retrieve, search, and manage different types of memories.
    16
    MIT

  • mem0-agent-memory

    arunkumars-mf
    A
    license
    Not graded
    quality
    D
    maintenance
    An MCP server that provides persistent memory capabilities for AI agents using Mem0, enabling storage, search, and management of contextual information across conversations with support for multiple backends and LLM providers.
    MIT

Appeared in Searches

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/akaiserg/mcp-memory-tracker'

If you have feedback or need assistance with the MCP directory API, please join our Discord server