back to work
Case Study / Consulting OS

Field Kit: A Self-Organizing Consulting OS

4 MCP servers, 70+ tools, a Telegram bot, and a weekly dreaming loop. Field Kit captures what I learn, notices what I actually use, and names the patterns in between — an organism, not an archive.

MCPSupabasepgvectorPython
claudecodetelegrammcptrendsresearchregulatorybrandsupabase · pgvector
10,052
Items indexed
4
MCP servers
70+
Tools shipped
<2s
Semantic search

Overview

SECTION 01

Problem

Consultants lose knowledge between projects. Every engagement generates insights - emerging trends spotted in client conversations, academic papers that explain phenomena, frameworks that worked well, patterns that keep appearing across industries. But this knowledge scatters: browser bookmarks with 200+ tabs never revisited, notes in project folders forgotten after handoff, mental models that fade without reinforcement, research done twice because you forgot you already found it.

Solution

A consulting OS that captures knowledge as you work — and then organizes itself. Field Kit started as a personal RAG system built on three principles: (1) Selfish software — build for your own needs first, (2) Minimal friction — add knowledge in the flow of work, (3) Compound returns — every signal, paper, and insight you capture makes future work easier. It grew a fourth: (4) Self-organization — the system tracks what gets retrieved, what gets used, and what gets used together, then runs a weekly “dreaming” loop that names the emerging patterns. MCP servers integrate it directly with Claude Desktop, Claude Code, and a Telegram bot.

The Challenge: Knowledge That Compounds

SECTION 02

Traditional knowledge management tools fail because they optimize for the wrong thing. They make it easy to organize knowledge but hard to capture and retrieve it.

What Consultants Need

  • Capture insights without breaking flow
  • Search semantically, not with keywords
  • Discover unexpected connections
  • Knowledge that compounds over time

What Traditional Tools Offer

  • Manual tagging and organization
  • Keyword search (misses connections)
  • Separate apps (context switching)
  • Static databases (don’t learn)

The gap between how knowledge workers think (associatively, across domains) and how tools work (hierarchically, in silos) creates friction at the worst moment - when you need the insight for a client deliverable.

The Architecture: 4 MCP Servers, 70+ Tools

SECTION 03

Rather than building a monolithic app, I created specialized MCP servers that integrate with Claude Desktop, Claude Code, and a Telegram bot via an MCP bridge. Each server handles a different dimension of consulting intelligence:

01

trend_monitor (33 tools)

Purpose: Track and analyze emerging signals in AI, sustainability, and policy. Monitor academic research. Track regulatory developments. Synthesize patterns across domains.

search_trendsadd_trendanalyze_signalconnect_signalssearch_papersadd_paperanalyze_papersearch_regulationstrack_regulation_timelineanalyze_regulatory_impactweb_researchparse_newsletter

Data: 267 trend signals, 216 academic papers, 10 regulatory provisions. Automated ingestion via GitHub Actions. Manual curation from client work and newsletters.

02

knowledge_base (21 tools)

Purpose: RAG over consulting IP — frameworks, case studies, and methods. Proprietary knowledge that compounds over time.

search_frameworksadd_frameworksearch_casesadd_casesearch_methodssearch_knowledgeget_kb_stats
03

market_researcher (13 tools)

Purpose: Brand intelligence and competitive analysis. Merged from a standalone multi-agent market research tool into the Field Kit ecosystem, enabling unified semantic search across all knowledge domains.

search_brandsget_brand_contextsearch_brand_reportssearch_allcompare_brandslink_brand_to_trendget_competitors
04

Telegram Bot — Conversational Interface

Purpose: Mobile-first access to the full knowledge system. A Claude Sonnet-powered conversational agent with an MCP bridge that routes queries to all four servers. Supports Swedish and English, maintains per-user conversation history, and runs agentic tool-use loops (up to 10 iterations per query).

MCPBridgeSSE transportDynamic tool discoveryTool routingConversation historyUser whitelist
05

Deployment: One Corpus, Three Sites

The same four servers run in three places, all sharing a single Supabase corpus: stdio locally for Claude Desktop and Claude Code, a Hetzner VPS running the Docker Compose stack (SSE endpoints on ports 8081-8084 with health checks) plus the Telegram bot, and a Mac mini running the MCP servers for an autonomous research agent. Add a signal from any surface and it is queryable from every other surface seconds later.

06

org_registry (6 tools)

Purpose: Organization canonicalization across the whole corpus. Brands, cases, and reports all reference organizations — org_registry keeps one canonical record per org with aliases, so “Uppsala University” and “Uppsala universitet” resolve to the same entity instead of fragmenting the knowledge graph.

find_orgget_orglist_orgsadd_orgadd_aliasesmerge_orgs

How Field Kit Learns: The Five-Layer Organism

SECTION 04

Most knowledge bases only grow. Field Kit also metabolizes: it notices what it uses, what it uses together, and what those together-things mean. The architecture is five layers, deliberately graded from SQL-cheap at the bottom to LLM-expensive only where reasoning is genuinely needed.

The Stack

L0

Substrate. Supabase (Postgres + pgvector), 30+ migrations, Row-Level Security on every table. Trends, papers, regulations, frameworks, cases, methods, brands, bundles — one corpus, shared embeddings.

L1

Counters. Every entry tracks retrieval_count (it showed up in search) and a quality-gated usage_count (it was cited in an answer that scored well). The gate is the move that prevents “popular” from being mistaken for “good.” Usage feeds back into ranking.

L2

Co-citation graph. When a quality-gated answer cites several entries together, every pair gains edge weight. Edges decay on a multiplicative half-life, so old habits fade unless they keep earning reinforcement. Pure SQL — no LLM involved.

L3

Dreaming. Weekly between-session jobs read the graph and add LLM synthesis where SQL can’t: naming emergent clusters, consolidating memory, proposing prompt revisions.

L4

Surface. The four MCP servers, the Telegram bot, a 20-question eval harness, and the public cockpit — a four-tab view (Pulse / Map / Radar / Dossiers) where load-bearing entries literally grow bigger and any entity opens to a one-page dossier.

01

The Weekly Dream (~$1 per run)

Every Sunday at 04:00 UTC, while I sleep, a GitHub Actions workflow runs the loop: benchmark the agent against 20 held-out consulting questions → run a generative probe that synthesizes ~10 fresh questions from the week’s ingestion → decay old co-citation edges → find hot connected components and have a small model name them as dreamed clusters → write everything into a Dream Review queue.

Dreamed clusters are not facts — they are weak proposals until reviewed. The Dream Review queue is where I accept, dismiss, or promote them. Two heavier dreams (memory consolidation and agent-prompt revision) run manually and always require a human-reviewed diff before applying.

02

Paper Bundles: The Editorial Layer

The paper firehose is allowed to stay large — 2,800+ papers and growing daily. Bundles are the layer that says what counts: curated groups with a title, a rationale, member roles, and a review status. A dreamed cluster with strong evidence gets promoted into a bundle; a bundle is something I can hand to a client conversation. Curation on top of the firehose, not instead of it.

03

The Eval Harness: Closing the Loop

A 20-question held-out benchmark with weighted rubrics tests the agent end-to-end against the live KB. Scored traces are what drive the quality gate: only answers above threshold increment usage counters and reinforce co-citation edges. The same scores feed the instruction dream, which proposes the next version of the agent prompt from low-scoring traces. Quality measurement isn’t a report — it’s the system’s feedback signal.

Key Innovation: Tunable Search Thresholds

SECTION 05

Most semantic search systems use fixed similarity thresholds. Field Kit makes it user-adjustable per search for different consulting moments:

ThresholdModeUse Case
0.3Ultra-broad discovery&ldquo;Show me anything remotely related&rdquo; — cross-domain pattern hunting
0.4Balanced discovery (default)&ldquo;Find interesting connections&rdquo; — normal consulting research
0.5Moderate precision&ldquo;Show me related work&rdquo; — academic literature review
0.6High precision&ldquo;Find exact matches&rdquo; — duplicate detection

Why This Matters

Traditional search: “AI ethics” → AI ethics papers only

Discovery search (0.3-0.4): “AI ethics” → Constitutional AI, service design principles, governance frameworks, alignment research, EU regulations

You want serendipity. The Constitutional AI paper (0.451 similarity) wouldn’t show at 0.6 threshold, but it’s exactly what a service designer needs for ethics work.

Real Production Usage

SECTION 06
01

Scenario 1: Client Question on Edge AI

Without Field Kit (old way): Google “edge AI research 2024” → sift through blog posts and vendor marketing → search Google Scholar → read 5-6 abstracts → synthesize manually. Time: 30-45 minutes.

With Field Kit (new way): search_trends("edge AI deployment", threshold=0.4) → 8 relevant signals → search_papers("edge AI efficiency") → 5 academic papers with citation counts → connect_signals([...]) → AI synthesis. Time: 3-4 minutes.

Result: Better answer (academic + trend signals + synthesis), 10x faster, with source citations ready for slides.

02

Scenario 2: Pattern Recognition Across Projects

Context: Notice similar challenges across 3 different clients — all struggling with internal AI governance, no clear decision-making framework for AI tool adoption.

Action: add_trend() with title “Enterprise AI Governance Vacuum”, analysis of pattern, strength “accelerating”, category “policy”.

Future value: Next client with similar challenge → search finds this pattern → reference 3 past cases → faster diagnosis, better recommendations. Compound returns in action.

Technical Foundation

SECTION 07

Stack Choices

  • Supabase: PostgreSQL + pgvector — managed Postgres with vector extensions, sub-2s search
  • MCP Servers: Python + FastMCP — Anthropic’s official MCP spec, fast iteration
  • Embeddings: OpenAI text-embedding-3-small — best cost/performance, $0.02 per 1M tokens
  • Interface: Claude Desktop + Telegram Bot + Claude Code — desktop, mobile, and CLI access via MCP and SSE bridge

Performance Metrics

  • Search latency: <2s (embedding + vector search + formatting)
  • Ingestion speed: 2-3s per item (arXiv metadata)
  • Batch processing: 50 items in <60s (RSS feeds)
  • Cost per query: $0.00002 (embedding only)
  • Current scale: 10,052 items across 8 content types
  • Theoretical capacity: 100,000+ items (pgvector scales to millions)
  • Security: Row-Level Security on all tables
Data Pipeline
Sources → Claude Filtering → Embedding Generation → Supabase (pgvector) → Semantic Search

Automated Ingestion (GitHub Actions - runs while you sleep):
1. arXiv RSS monitor: Daily scan for new papers in AI/ML categories
2. Trend RSS monitor: Scheduled scan of 9+ feeds (TechCrunch AI, VentureBeat, MIT Tech Review, etc.)
3. Claude Sonnet filters for consulting relevance
4. Auto-extract: title, analysis, strength, category, tags
5. Generate embedding → Store in Supabase with full metadata
6. Available for search immediately

Manual Ingestion:
- parse_newsletter: Paste newsletter content → extract 1-5 signals automatically
- add_paper: arXiv ID or DOI → auto-fetch metadata via OpenAlex/Semantic Scholar
- add_paper_manual: For papers not in indexed systems (title, authors, abstract)
- web_research: Perplexity-powered live research with optional signal extraction

Batch Ingestion:
- Zotero/BibTeX pipeline: Export .bib → ingest_bib.py → auto-classify research areas
- 13 category-specific batch scripts for seeding (RAG, agents, alignment, vision, etc.)

Deployment:
- Docker Compose with SSE transport (ports 8081-8084)
- Telegram bot via MCPBridge (dynamic tool discovery + routing)

Cost: ~$0.00001 per item for embeddings. 1000 items = $0.01.

Key Learnings

SECTION 08
01

Selfish Software Works

Building for your own acute pain point produces better products than building for hypothetical users. You use it daily, notice every friction point, iterate immediately. No user interviews needed - you ARE the user. The tunable search threshold (0.3-0.6) came from real frustration: “Sometimes I want broad discovery, sometimes I want exact matches. Why force me to choose one?”

02

MCP Changes the Integration Game

MCP servers eliminate the “build a UI” bottleneck for internal tools. Before MCP: Build backend → Build API → Build web UI → Deploy → Maintain. With MCP: Build backend → Build MCP server → Use in Claude Desktop. Iteration speed: 10x faster. When you DO want a web UI, the MCP server becomes your API. Nothing wasted.

03

Embeddings Are Cheap, Organization Is Expensive

Cost to embed 1000 items: $0.01. Time to manually tag and organize 1000 items: 20+ hours. Conclusion: Don’t optimize for embedding cost. Optimize for capture friction. Field Kit approach: Embed everything, search semantically. No folders, no tags.

04

Pattern Detection Requires AI Synthesis

Semantic search finds related items. That’s retrieval. Pattern detection finds meta-trends across items. That requires reasoning. Solution: connect_signals uses Claude Sonnet to analyze 2-5 signals together and synthesize common themes, implications, and strategic opportunities. You pick the signals, AI finds the patterns.

05

Knowledge Systems Have Compound Returns

Week 1: 20 signals, minor usefulness. Month 2: a few hundred signals and papers, frequently helpful. Today: 10,052 items across eight content types, with automated ingestion adding dozens daily. The curve is exponential, not linear. The catch: past a few thousand items, growth alone stops being the interesting part.

06

A Knowledge Base That Learns Needs Sleep

Once the corpus outgrew what one person can hold in their head, the bottleneck shifted from capture to sensemaking. The answer wasn’t a bigger search box — it was giving the system a between-session life: counters that record what gets used, a co-citation graph that records what gets used together, and a weekly dreaming loop that names the patterns. Two design rules made it safe: gate every feedback signal on answer quality (popularity is not truth), and treat everything the system dreams up as a proposal until a human accepts it.

Business Impact

SECTION 09

For Consulting Work

  • 30-45 min research → 3-4 min (10x faster)
  • Better answers (trends + academic + synthesis)
  • Pattern recognition across projects
  • Continuous learning between engagements

For Client Deliverables

  • Faster workshop prep (frameworks library)
  • Stronger proposals (cite trends + research)
  • Better presentations (synthesized insights)
  • More confident recommendations

For Personal Growth

  • Capture insights without breaking flow
  • Discover unexpected connections
  • Build expertise systematically
  • Create proprietary IP (frameworks, patterns)

ROI: Development time ~20 hours (MVP + iteration). Time saved per week ~2 hours. Break-even at 10 weeks. After 6 months: 50+ hours saved, plus a compounding knowledge advantage.

Current Scale

SECTION 10
5,336
Trend signals
4,328
Academic papers
21
Regulations
172
Frameworks
45
Case studies
32
Methods
24
Brands
94
Brand reports

All tables secured with Row-Level Security. Automated ingestion via GitHub Actions (arXiv daily, RSS scheduled). The system grows while you sleep.

Roadmap & Evolution

SECTION 11

Phase 1: Core Intelligence (✅ Complete)

  • trend_monitor MCP server, 267 trend signals, 216 academic papers
  • RSS feed automation with Claude filtering; semantic search with tunable thresholds (0.3-0.6)
  • Pattern detection via connect_signals; Supabase + pgvector with RLS; Claude Desktop + Code integration

Phase 2: Extended Intelligence (✅ Complete)

  • knowledge_base MCP server (frameworks, cases, methods); Perplexity live web research
  • Regulations table (EU AI Act, GDPR, NIS2); analyze_regulatory_impact; newsletter parsing
  • Paper full-text via ar5iv; GitHub Actions automation (arXiv daily, trend RSS scheduled)

Phase 3: Consulting OS (✅ Complete)

  • market_researcher MCP server (brand analysis, competitive intel); merger into unified system
  • search_all — unified semantic search across all domains; cross-domain linking; RLS everywhere

Phase 4: Multi-Interface & Deployment (✅ Complete)

  • Telegram bot with Claude Sonnet agent loop + MCP bridge; Docker Compose with SSE (ports 8081-8084)
  • MCPBridge for dynamic tool discovery and routing; stats tools on all servers
  • Manual + Zotero/BibTeX batch ingestion; flexible research areas; 4 new epistemology domains

Phase 5: The Self-Organizing Layer (✅ Complete)

  • Usage counters with quality gating; co-citation graph with half-life decay
  • Weekly dreaming workflow: benchmark → generative probe → decay → cluster naming → Dream Review (~$1/run)
  • Paper bundles; Dream Review queue (accept/dismiss/promote); 20-question eval harness wired into the loop
  • Public cockpit at /field-kit — four tabs (Pulse / Map / Radar / Dossiers); three-site deployment

What’s Next

Edge Evidence Drawer

Every edge in the graph should show the reason it exists: which AskBox thread cited both entries, which dream probe reinforced the pair, which bundle membership connects the evidence. Provenance for connections, not just nodes.

AskBox Trace Overlay

Clicking an AskBox thread highlights the retrieved and cited nodes in the graph — making actual use visible, not just archive structure.

"What Changed" Weekly Delta

A weekly view of new clusters, repeated questions, unbundled high-use papers, stale dream items, and emerging contradictions — the organism’s pulse, readable at a glance.

Graph Action Queue

Turn exploration into next actions: review this dreamed cluster, promote this bundle, write a field note, archive this noisy source, mark this edge as useful or noise.

Explore More