Sponsored by Deepsite.site

Tag

#RAG

207 results found

Scratchpad Mcp

scratchpad-mcp is an MCP server that gives AI agents persistent, token-efficient storage. It solves a specific waste problem: agents constantly re-read files they've already seen, re-summarize documents they've already processed, and re-load context they've already understood. Every one of those round-trips burns tokens for no new information. This server fixes that with eight tools designed around how agents actually work: Versioned writes. write_file automatically versions every write and keeps the 10 most recent versions per file. Storage is append-only on success and atomic on failure partial writes can't corrupt state. Structured diffs. read_file accepts a since_version parameter and returns a JSON line-diff against that prior version instead of the full content. Agents that have already seen v1 can ask "what changed in v3?" and get a small structured payload they can reason about, not the entire file again. Append-only logs. append_log and read_log give agents an event-stream they can replay. Cursor-based pagination (since_entry + last_entry_id + has_more) means an agent can checkpoint where it left off and resume cheaply. On-demand summaries. summarize_file calls Claude Haiku to summarize files over ~2000 estimated tokens. Summaries are cached per file version, so repeat calls on an unchanged file cost nothing. The threshold is enforced server-side you can't accidentally pay to summarize something small. Per-agent isolation. Every operation is scoped by an agent_id parameter, so one server instance can serve many agents without leaking state between them. Storage limits. 1 MB per file write, 64 KB per log entry, 1000 files / 100k log entries / 100 MB total per agent sane multi-tenant guardrails out of the box. Backed by a single SQLite file (Postgres migration is on the roadmap). All SQL is parameterized, paths are validated against a strict allowlist, and the security model is documented honestly it's safe for one-user-per-process deployments today, and the V2 plan derives agent_id from the caller's API key for true multi-tenancy. Build agents that remember what they've already seen.

Memtrace

Memtrace — Structural Memory for AI Coding Agents The Problem Every AI coding agent — Claude Code, Cursor, Codex, Copilot — starts each turn completely blank. It re-reads raw source files and re-derives the full call graph, type hierarchy, and import tree from scratch on every single invocation. That structural rework burns 60–90% of the context window before any real reasoning begins. Less than 5% of tokens in a typical agentic coding session contribute genuine new intelligence. The rest is expensive, redundant noise — and it compounds: accuracy drops 40% as sessions grow, stale context crowds out signal, and summaries strip out the structural relationships agents need most. The Solution Memtrace is a bi-temporal structural memory layer that turns your codebase into a live, queryable knowledge graph — compiled from the AST, not guessed from embeddings. Every function, class, interface, and API endpoint becomes a typed node with deterministic relationships. Every file save becomes a queryable episode with timestamps, so agents can reason about structure, detect regressions, and time-travel through their own work without re-reading anything. One Rust binary. Zero configuration. Five-minute install. What agents can do with it Find callers, callees, and dependencies instantly — no file scanning, no token waste Compute blast radius before making a change — know exactly what breaks before anything is touched Detect structural drift between sessions — catch regressions the moment they happen, not at PR review Time-travel through code evolution — query any prior state of any symbol, not just git commits Search across the full codebase with hybrid retrieval — BM25 full-text + HNSW vector + graph traversal fused in one query Map API topology across services — cross-repo HTTP call graphs, dependency chains, dead endpoint detection Benefits −90% token cost on structural queries (Mem0) +26% accuracy on multi-step agentic tasks (Mem0) −91% p95 latency on structural lookups vs. RAG baselines +32.8% SWE-bench bug-fix success rate when agents have graph context (RepoGraph) 200–800ms per-save re-indexing — every file save is a queryable episode in under a second 40+ MCP tools covering indexing, search, relationships, impact analysis, temporal evolution, API topology, graph algorithms, and direct Cypher queries 12 languages + 3 IaC formats supported via Tree-sitter grammars Local-first, closed-source Rust — code never leaves the machine, no account required, no telemetry

Careerproof

Career and workforce intelligence built on a deep HR ontology — skill taxonomies, role definitions and responsibilities, compensation and incentive structures, learning and development pathways, sourcing strategies, and role/skill evolution mapping. This structured foundation, combined with a RAG knowledge base curated from 50+ premium sources (HBR, McKinsey, BCG, Gartner, Forrester) and updated 3x daily with live web research, powers 6 guided skills and 42 MCP tools for two audiences: working professionals getting personalized career intelligence (CV optimization, salary benchmarking, career strategy), and HR/TA teams running structured talent evaluation, candidate shortlisting, compensation analysis, and consulting-grade workforce research reports. Example Use Cases (for HR/TA teams): 1. Custom Evaluation Models — Train CareerProof on your organization's existing assessment rubrics, scorecards, and evaluation criteria to build custom eval models that evaluate candidates through your specific lens. Upload your competency frameworks and historical assessments, then run inference on new candidates — scored and ranked exactly how your team would, at scale. 2. Candidate Evaluation & Shortlisting — Set up a hiring context with company profile and job description, upload candidate CVs, then batch-rank them with GEM competency scoring and JD-FIT matching. Apply your custom eval models for organization-specific scoring, or deep-dive any candidate with a 360-degree evaluation including tailored interview questions derived from skill taxonomy analysis. 3. Workforce Research Reports — Generate consulting-grade PDF reports across 16 types (salary benchmarking, skills gap analysis, org design, DEI assessment, succession planning, sourcing strategy, and more). Each report is grounded in real-time market data from premium sources and structured around HR ontology — role definitions, compensation structures, L&D pathways, and skill evolution mapping. 4. Compensation & Incentive Benchmarking — Get market-calibrated salary and total compensation intelligence for any role, location, and industry. Analysis is structured around compensation and incentive frameworks from the HR ontology, enriched with live web research and curated knowledge base data covering base salary, equity, bonuses, and benefits. Example Use Cases (for the working professional or career coach): 1. Career Intelligence Chat (Hyper-Personalized) — Ask career strategy questions and get hyper-personalized responses that fuse your CV context with deep insights from the career and workforce RAG knowledge base. Salary benchmarks calibrated to your function and location, industry disruption analysis mapped to your skill profile, and career pivot recommendations grounded in role evolution data — not surface-level answers, but intelligence drawn from the same sources that inform executive strategy. 2. CV Optimization (Hyper-Personalized) — Upload your CV and receive a hyper-personalized positioning pipeline that combines your actual experience with deep insights from our career and workforce RAG knowledge base. Market analysis calibrated to your industry and seniority, career opportunity identification grounded in role/skill evolution data, and targeted edits with trade-off analysis — not generic advice, but intelligence shaped by 50+ premium research sources and your unique career trajectory.

Codegraph Rust

🎯 Overview CodeGraph is a powerful CLI tool that combines MCP (Model Context Protocol) server management with sophisticated code analysis capabilities. It provides a unified interface for indexing projects, managing embeddings, and running MCP servers with multiple transport options. All you now need is an Agent(s) to create your very own deep code and project knowledge synthehizer system! Key Capabilities 🔍 Advanced Code Analysis: Parse and analyze code across multiple languages using Tree-sitter 🚄 Dual Transport Support: Run MCP servers with STDIO, HTTP, or both simultaneously 🎯 Vector Search: Semantic code search using FAISS-powered vector embeddings 📊 Graph-Based Architecture: Navigate code relationships with RocksDB-backed graph storage ⚡ High Performance: Optimized for large codebases with parallel processing and batched embeddings 🔧 Flexible Configuration: Extensive configuration options for embedding models and performance tuning RAW PERFORMANCE ✨✨✨ 170K lines of rust code in 0.49sec! 21024 embeddings in 3:24mins! On M3 Pro 32GB Qdrant/all-MiniLM-L6-v2-onnx on CPU no Metal acceleration used! Parsing completed: 353/353 files, 169397 lines in 0.49s (714.5 files/s, 342852 lines/s) [00:03:24] [########################################] 21024/21024 Embeddings complete ✨ Features Core Features Project Indexing Multi-language support (Rust, Python, JavaScript, TypeScript, Go, Java, C++) Incremental indexing with file watching Parallel processing with configurable workers Smart caching for improved performance MCP Server Management STDIO transport for direct communication HTTP streaming with SSE support Dual transport mode for maximum flexibility Background daemon mode with PID management Code Search Semantic search using embeddings Exact match and fuzzy search Regex and AST-based queries Configurable similarity thresholds Architecture Analysis Component relationship mapping Dependency analysis Code pattern detection Architecture visualization support