convez.ai
MCP Server
Sandeeprdy1729

timps

Sandeeprdy1729/timps

Ver no GitHub
BomPluginScore · de 0 a 100

The AI memory layer with 17 intelligence tools — catches contradictions, predicts burnout, tracks relationships. Model-agnostic, self-hosted

Instalação

$npx convez-ai Sandeeprdy1729/timps

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
6
Forks
2
Acompanhando
1
Saúde
100%
Último commit
há 1 semana
Versão
v0.1.1
Issues abertas
4
Contribuidores
2

README

A tradução para o português deste README ainda está na fila.

TIMPS — The AI Coding Agent That Remembers Everything

TIMPS is a persistent memory layer for AI coding agents. It remembers your codebase, your decisions, your bugs — so Claude, Cursor, Windsurf, or any MCP-compatible agent never makes you re-explain anything. 22-layer memory. 25 intelligence tools. 30-second install. Free.


Table of Contents


Try It Now (30 seconds)

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

That's it. No install, no config, no API key. TIMPS analyzes the current directory, builds a memory profile, and returns a rich analysis with context persistence. If you have Ollama running, everything is 100% free and local.

One-line install (Linux / macOS)

curl -fsSL https://raw.githubusercontent.com/Sandeeprdy1729/timps/main/install.sh | bash

CLI (after install)

npm install -g timps-code
cd your-project
timps "what does this codebase do?"

Auto-detects Ollama if running, or walks you through picking a provider:

timps --provider claude "refactor the auth module"    # Claude
timps --provider gemini "explain the architecture"    # Gemini
timps --provider ollama "quick fix"                   # Free local
timps --provider auto "analyze this codebase"        # Intelligent routing

MCP Server (Claude Code / Cursor / Windsurf)

npm install -g timps-mcp

Then add to ~/.claude.json (Claude Code), .cursor/mcp.json (Cursor), or ~/.config/windsurf/config.json (Windsurf):

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

VS Code Extension

Install from the marketplace or:

code --install-extension timps-ai-coding-agent

Full Server + Docker

git clone https://github.com/Sandeeprdy1729/timps
cd timps && docker compose up -d
npm install -g timps-mcp

Features

  • 🧠 22-layer persistent memory — 9 core layers (Working → HarmonicSheafWeaver) plus 13 advanced layers (EngramLog, ConsolidationEngine, SynapticPruner, ProvenanceForge, SpacedRepetitionForge, ConstitutionalGuard, AuditForge, ProspectiveTrigger, BiasRevealer, ContextVector, RehearsalEngine, SchemaDistorter, ConfidenceCalibrator). Memory survives across sessions, projects, and agent restarts.
  • 🔧 25 intelligence tools — 17 original (contradiction detection, burnout prediction, relationship tracking, etc.) plus 8 new (FalseMemoryDetector, ConfidenceCalibrator, SourceAttributor, ConflictResolver, MemoryAuditor, ProspectiveTrigger, BiasRevealer, SchemaInferrer). Every tool is class-based, deterministic (zero Math.random()), and benchmarked.
  • 💰 100% free with Ollama — Runs fully local. Zero API keys required. No telemetry. No cloud dependency.
  • 🔌 MCP native — Works out of the box with Claude Code, Cursor, Windsurf, Cline, Continue, Goose, OpenCode, and any MCP-compatible agent.
  • 🔄 Multi-provider — Claude, GPT, Gemini, DeepSeek, OpenRouter, Ollama, and custom endpoints. Intelligent auto-routing between providers.
  • 🧩 VS Code extension — Full editor integration with memory panel, skill composer, and inline intelligence.
  • 📱 Multi-surface — CLI agent, MCP server, VS Code extension, Tauri desktop app, and React Native mobile app.
  • 🔌 Plugin system — Extend TIMPS with custom plugins. Plugin SDK included.
  • 🏗️ Hybrid storage — SQLite for local/lightweight, optional PostgreSQL for teams, Qdrant for vector search.

Desktop App (macOS · Windows · Linux)

The TIMPS Desktop app is a cross-platform memory cockpit built with Tauri 2 and React. It visualizes your agent's persistent memory graph, provides a chat interface, and surfaces intelligence alerts from all 25 engines.

Download the latest release from the Releases page and install for your platform:

PlatformFormat
macOS (Intel).dmg (x86_64)
macOS (Apple Silicon).dmg (aarch64)
Windows.msi or .exe installer
Linux.deb or .AppImage

Or build from source:

cd packages/timps-desktop
npm install
npm run tauri:build

First launch: You'll see a "TIMPS is ready" welcome screen. Press ⌘⇧K for the command bar or ⌘⇧N for quick capture.

Key features:

  • 🧠 Memory Explorer — Browse semantic, episodic, patterns, and contradictions with filter chips
  • 💬 Chat — Conversational interface with inline tool call display and active memory recall panel
  • 🔔 Intelligence Alerts — Real-time feed from all 25 intelligence engines with dismiss/snooze
  • 🔌 Integrations — Connect GitHub, Telegram, Slack, Claude Code MCP, and more
  • 📊 Stats — Memory health score, most-touched files, peak hours, velocity trends
  • ⚙️ Settings — Provider selector with visual active-state indicator, memory retention controls

How It Works

graph TB
    User["🧑 Developer"] --> CLI["CLI Agent timps-code"]
    User --> VSC["VS Code Extension"]
    User --> MCP["MCP Server timps-mcp"]

    CLI --> Core["Memory Core"]
    VSC --> Core
    MCP --> Core

    subgraph Core["TIMPS Memory Core (22 layers)"]
        L1["L1 Working"]
        L2["L2 Episodic"]
        L3["L3 Semantic"]
        L4["L4 Procedural"]
        L5["L5 ChronosForge"]
        L6["L6 ResonanceForge"]
        L7["L7 EchoForge"]
        L8["L8 SynapseQuench"]
        L9["L9 HarmonicSheafWeaver"]
        L10["L10 EngramLog"]
        L11["L11 ConsolidationEngine"]
        L12["L12 SynapticPruner"]
        L13["L13 ProvenanceForge"]
        L14["L14 SpacedRepetitionForge"]
        L15["L15 ConstitutionalGuard"]
        L16["L16 AuditForge"]
        L17["L17 ProspectiveTrigger"]
        L18["L18 BiasRevealer"]
        L19["L19 ContextVector"]
        L20["L20 RehearsalEngine"]
        L21["L21 SchemaDistorter"]
        L22["L22 ConfidenceCalibrator"]

        L1 --> L2 --> L3 --> L4 --> L5 --> L6 --> L7 --> L8 --> L9
        L9 --> L10 --> L11 --> L12 --> L13 --> L14 --> L15
        L15 --> L16 --> L17 --> L18 --> L19 --> L20 --> L21 --> L22
    end

    Core --> Tools["25 Intelligence Tools"]
    Tools --> Storage["Hybrid Storage"]

    Storage --> SQLite["SQLite Local"]
    Storage --> PG["PostgreSQL Team"]
    Storage --> Qdrant["Qdrant Vector"]

    subgraph Providers["LLM Providers"]
        Ollama["Ollama 🌿 Free"]
        Claude
        GPT
        Gemini
        DeepSeek
    end

    Core --> Providers

When you ask TIMPS a question, the request flows through the 22-layer memory system. Each layer enriches the context: Working memory holds the immediate session, Episodic recalls past sessions, Semantic provides knowledge graph relationships, Procedural injects learned workflows, the forge layers (5–9) handle time-series analysis, resonance matching, pattern synthesis, associative recall, and harmonic weaving, and the advanced layers (10–22) add immutable audit trails, provenance tracking, spaced repetition, constitutional guardrails, bias detection, and confidence calibration. The 25 intelligence tools process the enriched context before returning a response that's grounded in everything TIMPS has learned about your codebase.


Comparison

FeatureTIMPSagentmemoryClaude CodeMemGPT/LettaClineContinueCursor
Persistent Memory✅ 22 layers✅ SQLite❌✅❌❌❌
25 Intelligence Tools✅❌❌❌❌❌❌
Free (Ollama)✅✅❌⚠️ Partial❌✅❌
MCP Native✅✅✅❌❌❌❌
VS Code Extension✅❌❌❌✅✅✅
Burnout Detection✅❌❌❌❌❌❌
Contradiction Detection✅❌❌❌❌❌❌
Multi-Provider✅ 7 providers✅❌ 1 provider❌✅✅❌
Self-Hosted✅✅❌✅❌❌❌
Mobile App🟡 Experimental❌❌❌❌❌❌
Plugin System✅✅ (skills)✅ (sub-agents)❌✅❌✅

Use Cases

  • "I use Claude Code and I'm tired of re-explaining my codebase every session." TIMPS persists everything — architecture decisions, bug patterns, API conventions — across sessions, projects, and restarts.
  • "I run Ollama locally and want an AI agent that doesn't phone home." TIMPS is 100% local with Ollama. Zero telemetry, zero API calls, zero cloud dependency.
  • "I manage a large monorepo and my agent keeps forgetting context." TIMPS's 22-layer memory handles codebases of any size. The forge layers (ChronosForge, HarmonicSheafWeaver) specialize in long-term pattern recognition and cross-file relationship mapping.
  • "I want my AI agent to learn from its mistakes." Contradiction detection, burnout prediction, and anomaly scoring let TIMPS identify when it's giving bad advice and avoid repeating errors.
  • "I'm building an MCP-powered toolchain and need memory that works across agents." TIMPS is MCP-native. Connect it to Claude Code, Cursor, Windsurf, Cline, Continue, Goose, OpenCode — any MCP client — and share memory across all of them.

Memory Architecture

The 22-layer memory system is TIMPS's core differentiating feature. Each layer serves a specific role in persisting and enriching context:

LayerStoragePersistenceContents
L1 WorkingIn-processReset on exitCurrent goals, active files, recent errors
L2 Episodicepisodes.jsonlDisk (append-only)Conversation summaries, outcomes
L3 Semanticsemantic.jsonDisk (permanent)Patterns, conventions, decisions
L4 Proceduralprocedural.jsonDiskWorkflows, recipes, skills
L5 ChronosForgechronos/DiskCausal graph, temporal dependencies
L6 ResonanceForgeresonance.jsonDiskPattern harmonics, oscillation model
L7 EchoForgeecho/DiskReservoir states, BFS context
L8 SynapseQuenchIn-memory + diskCross-layerCoherence scores, conflict map
L9 HarmonicSheafWeaversheaf/DiskSheaf Laplacian, cohomology result
L10 EngramLogengram.log.jsonlDisk (append-only)Immutable hash-chained audit trail
L11 ConsolidationEngineIn-memory + diskOn demandEpisodic → semantic promotion
L12 SynapticPrunermemory-meta.jsonDiskActive forgetting by importance
L13 ProvenanceForgeprovenance/Disk (permanent)Source tracking, chain of custody
L14 SpacedRepetitionForgeIn-memoryRuntimeSM-2 scheduling for review
L15 ConstitutionalGuardIn-memoryRuntimeLow-confidence write prevention
L16 AuditForgeIn-memoryOn demandWeekly memory health reports
L17 ProspectiveTriggerprospective-triggers.jsonDisk"When X, surface Y" triggers
L18 BiasRevealerIn-memoryOn demandOver/under-representation analysis
L19 ContextVectorcontext-vectors.jsonDiskState-dependent recall encoding
L20 RehearsalEnginerehearsal-items.jsonDiskSpaced retrieval practice
L21 SchemaDistorterschema-patterns.jsonDiskSchema-driven distortion detection
L22 ConfidenceCalibratorconfidence-calibrations.jsonDiskMulti-signal confidence scoring

Each project gets isolated memory keyed by SHA256 hash of its absolute path. All 22 layers ship in packages/memory-core.

Memory Branches

Memory is scoped per git branch, just like code:

timps --branch auth-refactor "analyze the auth module"

When the branch is merged, memory is merged into main if patterns are generally useful, archived if branch-specific, or discarded if abandoned. Data is never deleted — it moves to an archived/ subtree.


Performance / Benchmarks

All 25 intelligence tools are benchmarked continuously against a standardized evaluation suite. Results are tracked per-commit to prevent regression.

MetricTIMPSagentmemorymem0Letta
Recall@5 (LongMemEval-S)95%95.2%72%68%
MRR0.820.8820.710.65
Contradiction Detection100% (10/10)———
Intelligence Tools100% (25/25)———
Avg Latency (recall)17ms45ms120ms200ms
Scalability (500 facts)0.6ms mean / 1ms p95———

Run the benchmark suite locally:

npx tsx benchmark/index.ts --quick

All tools are deterministic — zero Math.random() calls in the intelligence layer.


25 Intelligence Tools

TIMPS ships 25 class-based intelligence tools in packages/memory-core/src/intelligence/, each designed for a specific cognitive function:

#ToolPurpose
1AetherWeftAnalyzes code sentiment and emotional patterns in commit messages
2ApexSynapseCross-reference detection between concepts
3AtomChainSemantic chunking of large documents
4BindWeaveLinks related facts into knowledge clusters
5ChronosVeilTemporal pattern detection and anomaly detection
6CurateTierAutomatic memory importance scoring
7EchoForgeGenerates analogies and metaphors for concepts
8ForgeLinkCreates bidirectional links between knowledge nodes
9GovernTierMemory access control and policy enforcement
10LayerForgeManages hierarchical memory layer transitions
11NexusForgeIdentifies central concepts and hub nodes
12PolicyMetabolExtracts and enforces project policies from memory
13SkillWeaveComposes skills into coherent system prompts
14SynapseMetabolonCross-session pattern synthesis and insight generation
15TemporaTreeManages temporal knowledge graphs with decay
16ArchitectureDriftDetects drift between documented and actual architecture
17VelocityTrackerTracks feature velocity and development patterns
18FalseMemoryDetectorFlags memories with weak provenance as false-memory risk
19ConfidenceCalibratorCalibrates confidence from similarity, reliability, evidence, freshness
20SourceAttributorReturns human-readable provenance chain for any memory
21ConflictResolverJaccard + sentiment-flip analysis for contradictory memories
22MemoryAuditorWeekly health audit: weak, contradicted, outdated, unsourced
23ProspectiveTrigger"When X happens, surface Y" trigger registration
24BiasRevealerOver/under-representation analysis in saved memory
25SchemaInferrerAuto-extracts typed schemas from episode/semantic stream

Every tool is deterministic (zero Math.random()), benchmarked, and backed by file-based JSON storage.


Swarm Architecture

TIMPS includes a 10-agent swarm that decomposes complex tasks across specialist agents. The fan-out is local — all agents run in-process, not distributed:

AgentJob
Product ManagerRequirements decomposition
ArchitectSystem design and technology selection
Code GeneratorImplementation
ReviewerCode review and quality checks
QATest generation
SecuritySecurity audit
PerformancePerformance analysis
DevOpsDeployment configuration
DocumentationDocstring and README generation
OrchestratorCoordinates the DAG

Launch via timps --swarm "design a microservices auth system" or /swarm from the REPL.


Multi-Surface Support

SurfaceStatusPackage
CLI🟢 Stabletimps-code
MCP Server🟢 Stabletimps-mcp
VS Code🟢 Stabletimps-ai-coding-agent
Desktop (Tauri)🟢 Stable@timps/timps-desktop
Mobile🟡 Experimental@timps/mobile
Docker🟢 Stablecompose.yaml
npm library🟢 Stable@timps/memory-core

MCP Ecosystem

TIMPS exposes 61 tools as an MCP server (timps-mcp) so any MCP-compatible client gets persistent memory, intelligence, and velocity tracking. The provider-agnostic adapter layer routes every request through a unified interface — no matter which LLM you use (Claude, GPT, Gemini, Ollama, OpenRouter, DeepSeek, or custom endpoints), the memory system, tool execution, and agent loop behave identically:

                  timps CLI / MCP / VS Code
                         │
              ┌──────────┴──────────┐
              │   Provider Router    │
              │   (auto-detect)      │
              └──────────┬──────────┘
              ┌──────────┼──────────┐
              │          │          │
         ┌────▼───┐  ┌──▼───┐  ┌──▼────┐
         │ Claude │  │GPT-4o│  │Gemini │
         └────┬───┘  └──┬───┘  └──┬────┘
              │          │          │
         ┌────▼───┐  ┌──▼───┐  ┌──▼────┐
         │Ollama  │  │ Groq │  │OpenRouter
         └────────┘  └──────┘  └───────┘

This means you can switch from Claude to Ollama by changing one flag with zero behavioral difference in how memory and tools work.

Claude Code / Cursor / Windsurf / Cline / Continue / Goose / OpenCode / any MCP client
         │
    ┌────▼────┐
    │timps-mcp│  npm install -g timps-mcp
    └────┬────┘
         │
    ┌────▼────┐
     │ Memory  │  61 tools across 6 categories
    │Engine   │  + 17 intelligence tools
    └─────────┘

Configuration

Environment Variables

VariableDefaultDescription
ANTHROPIC_API_KEY—Anthropic (Claude) API key
OPENAI_API_KEY—OpenAI API key
GEMINI_API_KEY—Google Gemini API key
OPENROUTER_API_KEY—OpenRouter API key
TIMPS_MODELclaude-3-5-sonnet-20241022Model string (prefix with ollama/ for local)
TIMPS_URL—Remote timps server URL (MCP mode)
TIMPS_TOKEN—Auth token for remote server
PROJECT_PATHprocess.cwd()Project root for memory scoping

CLI Reference — Slash Commands

CommandDescription
/helpShow help
/memory statsMemory usage statistics
/memory search <q>Search semantic memory
/memory clearClear working memory
/memory resetWipe all memory for this project
/skills listBrowse skill marketplace
/skills search <q>Search available skills
/skills install <id>Install a skill
/skills show <id>View installed skill content
/git statusGit status
/git diffWorking tree diff
/git commitWrite commit message with context
/swarmLaunch multi-agent swarm analysis
/sheafHarmonic sheaf analysis & prediction
/echoEchoForge resonance status
/exitSave snapshot and exit

CLI Flags

FlagPurposeExample
--providerSelect provider--provider claude
--modelSelect model--model gpt-4o
--configSetup wizard--config
--branchStart from memory branch--branch my-feature
--swarmMulti-agent mode--swarm "design auth system"

FAQ

Does it work offline?
Yes. With Ollama, every operation runs locally with zero internet required.

What LLMs are supported?
Ollama (free, local), Claude, GPT-4o, Gemini, DeepSeek, OpenRouter, and custom OpenAI-compatible endpoints.

How is data stored?
Default is local SQLite. Optionally PostgreSQL (teams) and/or Qdrant (vector search). All storage is local-only unless you configure a remote database.

Is there a hosted version?
Not yet. TIMPS is self-hosted by design. Cloud hosting is on the roadmap.

Can I use TIMPS without Ollama?
Yes. TIMPS auto-detects available providers. If Ollama isn't running, it walks you through connecting to Claude, GPT, or another provider.

How does TIMPS compare to agentmemory?
TIMPS has 22 memory layers vs 1, 25 intelligence tools vs 0, supports 7 providers vs 3, includes a VS Code extension, mobile app, and plugin system. agentmemory is simpler and SQLite-only.

Can I contribute my own intelligence tools?
Yes. See the plugin SDK in packages/plugin-sdk/ and the contributing guide in CONTRIBUTING.md.

How does the swarm work?
TIMPS includes a 10-agent swarm (Product Manager, Architect, Code Generator, Reviewer, QA, Security, Performance, DevOps, Documentation, Orchestrator) that decomposes complex tasks across specialist agents. The fan-out is local — all agents run in-process. Launch via timps --swarm "your task" or /swarm from the REPL.

What surfaces are supported?
CLI (timps-code), MCP server (timps-mcp), VS Code extension, Tauri desktop app (packages/timps-desktop/), React Native mobile app (apps/mobile/), and Docker deployment.

Is there a GUI?
Yes — VS Code extension (native), Tauri desktop app (packages/timps-desktop/), and a React Native mobile app (apps/mobile/).


Documentation

| File | What it covers | |---|---|---| | ARCHITECTURE.md | 22 memory layers, 25 tools, benchmark, CI, MCP internals | | AGENTS.md | AI agent instructions for this repo | | CONTRIBUTING.md | PR checklist, skills, changesets | | CHANGELOG.md | Version history & roadmap |

Package READMEs

READMEPackage
timps-code/README.mdCLI agent
timps-mcp/README.mdMCP server
timps-vscode/README.mdVS Code extension
packages/server/README.mdFull server + REST API
packages/memory-core/README.mdMemory engine
packages/plugin-sdk/README.mdPlugin SDK
apps/mobile/README.mdMobile app

Workflow Recipes

Four ready-to-use YAML workflows for Claude Code and other AI coding agents:

WorkflowWhat it does
code-review.yamlReview staged/branch changes for bugs, security, style
debug-session.yamlSystematic debug: reproduce, isolate, fix, verify
deploy-check.yamlPre-deploy safety checklist
feature-plan.yamlPlan and scaffold a new feature with tests

Contributors

Contributions of all kinds are welcome — code, docs, translations, plugins, or bug reports. See CONTRIBUTING.md to get started.

Bounty Program

We run periodic bounty contests for major features. Check Discord for active bounties!


Sponsors

TIMPS is free and open source. If you find it valuable, consider supporting development:


Star History


Community


License

MIT

Ver o original no GitHub

Bom para

Relacionados