Back to Browse

Timps MCP Server

by TIMPSs
Developer ToolsUse Caution4.2MCP RegistryLocal
Free

Server data from the Official MCP Registry

Persistent memory with contradiction detection, burnout monitoring, and 69 intelligence tools.

About

Persistent memory with contradiction detection, burnout monitoring, and 69 intelligence tools.

Security Report

4.2
Use Caution4.2High Risk

TIMPS is a legitimate MCP server for persistent AI coding agent memory with reasonable architecture. However, there are security concerns around network access permissions, unencrypted credential handling in config files, and some risky subprocess/shell execution patterns that users should be aware of. The code quality is generally good with proper error handling, but credential management could be more robust. Supply chain analysis found 4 known vulnerabilities in dependencies (0 critical, 1 high severity). Package verification found 1 issue (1 critical, 0 high severity).

4 files analyzed · 12 issues found

Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.

Permissions Required

This plugin requests these system permissions. Most are normal for its category.

File System Read

Reads files on your machine. Normal for tools that analyze or process local data.

File System Write

Writes or modifies files on your machine. Check that this is expected for the tool.

env_vars

Check that this permission is expected for this type of plugin.

HTTP Network Access

Connects to external APIs or services over the internet.

Shell Command Execution

Runs commands on your machine. Be cautious — only use if you trust this plugin.

process_spawn

Check that this permission is expected for this type of plugin.

system_info

Check that this permission is expected for this type of plugin.

Unverified package source

We couldn't verify that the installable package matches the reviewed source code. Proceed with caution.

What You'll Need

Set these up before or after installing:

URL of the TIMPS MemoryServer (e.g. http://localhost:4100). If not set, uses local file-based memory.Optional

Environment variable: TIMPS_URL

URL of the TIMPS MemoryServer for memory operations. Set to same as TIMPS_URL when using the full stack.Optional

Environment variable: TIMPS_MEMORY_URL

API key for authenticating with TIMPS MemoryServer. Generate via POST /auth/key on the server.Required

Environment variable: TIMPS_API_KEY

Project path for local memory storage. Defaults to current working directory.Optional

Environment variable: TIMPS_PROJECT_PATH

How to Install

Add this to your MCP configuration file:

{
  "mcpServers": {
    "io-github-sandeeprdy1729-timps": {
      "env": {
        "TIMPS_URL": "your-timps-url-here",
        "TIMPS_API_KEY": "your-timps-api-key-here",
        "TIMPS_MEMORY_URL": "your-timps-memory-url-here",
        "TIMPS_PROJECT_PATH": "your-timps-project-path-here"
      },
      "args": [
        "-y",
        "timps"
      ],
      "command": "npx"
    }
  }
}

Documentation

View on GitHub

From the project's GitHub README.

TIMPS — Persistent Memory for AI Coding Agents

Status: solo project, early. The MCP server and CLI are the parts I actually use daily and trust. Everything else in this repo (desktop app, mobile, JetBrains, plugin marketplace) is younger and less tested — flagged below. I'd genuinely rather you try the core and tell me it's broken than read marketing copy.


Try it in 30 seconds

npx timps-code "what does this codebase do?"

No install, no config, no API key. Point it at any repo. If you have Ollama running locally, this is 100% free and nothing leaves your machine. If not, it'll walk you through picking a provider.

To actually get persistent memory in Claude Code, Cursor, or any MCP client, add the MCP server:

npm install -g @timps-ai/timps-mcp

then point your MCP client at it (config instructions in MCP Setup).


What it actually does

Ask Claude Code to fix a bug today. Close the session. Ask it something related tomorrow — it has no idea what you decided yesterday, what you already tried, or why you structured something the way you did. You end up re-explaining the same context every single session.

TIMPS sits between you and your agent as an MCP server and keeps a memory store per project:

  • What it remembers — architectural decisions you've made, patterns and conventions specific to your codebase, bugs you've already hit and how they were fixed, and a plain audit log of what it wrote and why.
  • Where it lives — local JSON/SQLite files by default, keyed per-project so different repos don't bleed into each other. Optional Postgres/Qdrant if you want it shared across a team.
  • What it costs — free if you run Ollama locally. Optional paid providers (Claude, GPT, Gemini) if you want their reasoning quality instead.

That's the whole pitch. It's a memory layer, not a new agent — it works alongside whatever coding agent you already use.


How it works (short version)

Under the hood, memory is organized in a few real tiers:

  1. Working memory — current session: active files, recent errors, live goals. Cleared on exit.
  2. Episodic memory — a log of past sessions and their outcomes.
  3. Semantic memory — the durable stuff: patterns, conventions, decisions that got promoted from episodic because they kept mattering.
  4. Audit trail — an append-only, hash-chained log of every memory write, so you can see exactly what the system learned and when.

There's a deeper set of subsystems on top of this (temporal pattern detection, contradiction detection, confidence scoring, importance-based pruning) for people who want to go further — full breakdown in ARCHITECTURE.md rather than here, since most people don't need to know the internals to use it.


MCP Setup

Claude Code

Add to ~/.claude.json:

{
  "mcpServers": {
    "timps": {
      "command": "timps-mcp"
    }
  }
}

Cursor

Add to .cursor/mcp.json:

{
  "mcpServers": {
    "timps": {
      "command": "timps-mcp"
    }
  }
}

Windsurf

Add to ~/.config/windsurf/config.json:

{
  "mcpServers": {
    "timps": {
      "command": "timps-mcp"
    }
  }
}

Any other MCP client

Run timps-mcp over stdio. That's all the protocol requires.


What's measured, honestly

Run yourself: npx tsx benchmark/index.ts --quick

MetricResult
Recall@5 (20 test queries against a 50-fact synthetic corpus)19/20
Contradiction detection (10 known contradictory pairs)10/10
Query latency, in-process, 500 facts~1ms p95

These are self-run benchmarks on a synthetic dataset I built — not independently verified, and not a claim about how it performs on your actual codebase. Take them as "the core logic works as designed," not as a competitive claim.


Also in this repo (early / experimental)

The monorepo includes a VS Code extension, a desktop app (Tauri), a mobile app, a JetBrains plugin, and a multi-agent "swarm" mode for task decomposition. These exist and mostly work, but they've had far less real-world use than the CLI/MCP core — treat them as "try if you're curious," not "this is production-ready." I'd rather be upfront about that than have you find out the hard way.


Try it, then tell me what's wrong

This is genuinely useful to me right now: run the 30-second command above on one of your real repos, and tell me what broke, what was confusing, or what it got wrong. That feedback is worth more to this project than a star.

License

MIT

Reviews

No reviews yet

Be the first to review this server!