The ChurnFlow MCP Server is an ADHD-friendly productivity system that uses AI to intelligently capture, route, and manage tasks with minimal cognitive overhead.
Capture and route text input: Process raw text containing single or multiple items, with AI automatically inferring context, categorization, and priority. Supports optional context hints (business, personal, project, system) and priority levels (high, medium, low). Low-confidence items are routed for human review.
Get system status: Retrieve current operational state and general information about the ChurnFlow system and trackers.
List available trackers: Display all active productivity trackers with their context types and status, with optional filtering by specific context types.
Creates and manages markdown-based tracker files with YAML frontmatter for organizing tasks, projects, and reference materials
Integrates with OpenAI's API to provide AI-powered task categorization, prioritization, and automatic routing of captured items
Uses YAML frontmatter in tracker files for metadata management and workflow control of productivity items
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@ChurnFlow MCP Server capture 'need to schedule dentist appointment for next week'"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An ADHD-friendly productivity system powered by AI agents, SQLite database, and GitHub Copilot
ChurnFlow is a production-ready Model Context Protocol (MCP) server that transforms the way ADHD minds manage productivity. Built with optional SQLite database integration, GitHub Copilot support, and comprehensive AI assistance, ChurnFlow works with your natural patterns of thinking, capturing, and processing information.
v0.4.1 Highlights:
Database CLI Commands: Search, analytics, and review query commands
MCP Database Tools: Expose database features through GitHub Copilot
Enhanced Dashboard: Database-powered statistics and insights
Search Interface: Full-text search integration with CLI
🗄️ SQLite Database Integration: Optional advanced features with full-text search, analytics, and AI learning
🔍 Full-Text Search (FTS5): Search across all captures with ranking and relevance scoring
📊 Analytics Dashboard: Track inbox, active, completed, and overdue items with real-time statistics
🧠 AI Learning Patterns: Context inference improves over time with user feedback
🏗️ Clean Architecture: Database setup separated from capture operations (resolves code smells)
📁 Dual Storage: Captures save to both markdown files AND SQLite database
🔄 Optional Enhancement: System works perfectly in file-only mode when database not set up
Related MCP server: Coach AI
Traditional productivity systems fail ADHD brains because they require too much cognitive overhead:
Capture friction: Great ideas get lost while driving, in meetings, or during hyperfocus sessions
Processing overhead: Spending more time organizing tasks than actually doing them
Context switching pain: Losing track of where you were after interruptions
System maintenance burden: The productivity system becomes another task to manage
ChurnFlow uses AI to eliminate the cognitive overhead of productivity management:
🎤 Frictionless Capture: Voice or text input that automatically infers context and routing
🤖 AI-Powered Processing: Natural language understanding that categorizes and prioritizes items
📍 Context Awareness: Seamlessly switch between life domains (business, personal, projects)
🔄 Automatic Recovery: Get back on track after interruptions without losing momentum
ChurnFlow is built around three core concepts:
Domain-specific folders that archive completed work and reference materials:
gsc-ai/ - AI consulting business
project-55/ - Personal business empire plan
tractor/ - Equipment restoration projects
Active markdown files that capture ongoing work and action items:
Auto-categorized by context (business, personal, project, system)
YAML frontmatter for metadata and workflow control
Natural language task formatting with AI assistance
Intelligent routing that understands your workflow:
Context detection from existing tracker patterns
Item type classification (action, review, reference, someday/maybe)
Automatic prioritization and dependency discovery
Node.js 18+
GitHub Copilot or compatible AI assistant
OpenAI API key for AI inference
Existing Churn system directory structure
# Clone the repository
git clone https://github.com/jgsteeler/churnflow-mcp.git
cd churn-mcp
# Install dependencies
npm install
# Build the project
npm run build
# Setup database (optional - enables advanced features)
npm run db:setupCreate churn.config.json:
{
"collectionsPath": "/path/to/your/Collections",
"trackingPath": "/path/to/your/tracking",
"crossrefPath": "/path/to/crossref.json",
"aiProvider": "openai",
"aiApiKey": "your-openai-key",
"confidenceThreshold": 0.7
}Set up GitHub Copilot (see MCP-SETUP.md for complete guide)
Configure GitHub Copilot with ChurnFlow MCP server:
{
"mcpServers": {
"churnflow": {
"command": "tsx",
"args": ["/path/to/churn-mcp/src/index.ts"],
"cwd": "/path/to/churn-mcp"
}
}
}Start the MCP server:
npm run mcpUse with GitHub Copilot:
"Use ChurnFlow to capture 'Need to call parts supplier about carburetor for John Deere restoration'"
"What's the status of my ChurnFlow system?"
"Show me my available ChurnFlow trackers"
Database setup enables advanced features while maintaining full file-based compatibility:
# Setup database (one-time)
npm run db:setup
# Reset database (development)
npm run db:reset
# View database (browser)
npm run db:studioDatabase Features:
🔍 Full-text search across all captures
📊 Analytics dashboard with statistics
🧠 AI learning that improves over time
📋 Review prioritization for ADHD workflows
File-Only Mode: ChurnFlow works perfectly without database setup - all captures save to markdown files as usual.
# Direct capture via CLI
npm run cli capture "Complex task with multiple components"
# Check system status
npm run cli statusGitHub Copilot Ready: Full MCP server with three tools (capture, status, list_trackers)
Multi-AI Support: Works with any MCP-compatible AI assistant
Natural Conversations: "Use ChurnFlow to capture..." or "What should I work on?"
Cross-Interface Sync: Seamless between AI assistants and CLI
Multi-Item Processing: Single brain dump generates multiple routed items
Context Inference: AI routes to appropriate trackers automatically
Natural Language: "Working on Gibson website, need to call client, update docs"
Confidence-Based Routing: High confidence items placed directly, low confidence flagged for review
Complete Review Integration: Low-confidence items properly routed through ReviewManager for human oversight
ISO Date Standards: Consistent 2025-09-16 and 2025-09-16 14:30 formats
Priority Indicators: Visual emojis (🚨 ⏫ 🔼 🔻) for quick scanning
Section Placement: Items go exactly where they belong in tracker files
ADHD-Friendly: Clean, consistent output reduces cognitive load
176+ Comprehensive Tests: Full test coverage across all components including database
Dual Storage System: Redundant file + database storage with graceful fallback
Error Handling: Graceful degradation ensures no thoughts are lost
Emergency Capture: Always saves input even when systems fail
Clean Architecture: Database setup separated from capture operations
Multi-Item Support: Doug welder example processes complex scenarios
ChurnFlow is developed by Gibson Service Company, LLC - Development Division (GSC Dev), the R&D arm of a multi-division business focused on bringing joy-driven solutions to market.
Other GSC Divisions:
Gibson Service Company: Small engine repair & vintage tractor restoration (gibsonsvc.com)
GSC AI Consulting: AI-powered workflows for small businesses
Project-55: Building financial independence through passion-driven entrepreneurship
We welcome contributions from the ADHD and neurodivergent community! Please see our Contributing Guidelines for details.
v0.2.1: Multi-item capture with cross-tracker routing
v0.2.2: Complete formatting consistency and perfect section placement
v0.3.0: MCP server integration with GitHub Copilot support
v0.3.1: Review Process system foundation
v0.3.2: Complete ADHD dashboard & task management system
v0.3.3: Complete task editing and lifecycle management
v0.3.4: Review system integration - complete capture → review → action workflow
v0.4.0: Complete SQLite database integration with FTS, analytics, and AI learning
Capture input refinements: Enhanced AI processing and edge cases
Priority detection: Improved priority inference from natural language
Multi-item enhancement: Improved multi-item capture from complex inputs
Edge case handling: Better handling of ambiguous or unusual inputs
Confidence scoring: Refined confidence algorithms for routing decisions
v0.4.4: Context-aware dashboard views with database backing
v0.4.5: Inferred due dates with AI learning patterns
v0.4.6: Enhanced MCP server with database-powered tools
v0.5.0: Voice memo capture system with database integration
v0.6.0: Smart sync system with database analytics
v0.7.0+: Advanced AI features, mobile app, community features
All future features leverage SQLite database foundation
Dual storage (files + database) ensures backwards compatibility
Database analytics and learning enhance every feature
Clean migrations enable safe schema evolution
MVP refinements based on real usage patterns
Incremental improvements over major rewrites
Database insights drive UX optimizations
Maintain zero-friction capture workflow
v0.4.0 database integration completed in focused sessions
Each version builds incrementally on solid foundation
Database infrastructure enables rapid feature development
Clear, bounded objectives for each release
MIT License - see LICENSE for details.
Built with ❤️ for the ADHD community by someone who gets it.
Capture and route text input using ChurnFlow ADHD-friendly AI system
| Name | Required | Description | Default |
|---|---|---|---|
| context | No | Optional context hint for routing (business, personal, project, system) | |
| priority | No | Priority level for the captured content | |
| text | Yes | Text to capture and route (can contain multiple items) |
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 mentions 'capture and route' but doesn't explain what 'route' entails (e.g., where the text goes, how it's processed, or any side effects). There's no information on permissions, rate limits, or what happens after routing, leaving significant gaps for a tool that likely involves data handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core action ('Capture and route text input') and specifies the system. There's no wasted verbiage, and every word contributes to understanding the tool's purpose, making it appropriately concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a tool that captures and routes text, with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits, output format, or how routing works, which are crucial for an agent to use it correctly. The description alone is insufficient for a tool with potential side effects and undefined results.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description adds no additional meaning beyond what's in the schema (e.g., it doesn't clarify 'routing' behavior related to parameters). With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but also doesn't detract.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Capture and route text input' with the specific system 'ChurnFlow ADHD-friendly AI system'. It distinguishes from siblings like 'list_trackers' and 'status' by focusing on input capture rather than listing or checking status. However, it doesn't explicitly differentiate from potential similar tools beyond the named siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. There's no mention of when to choose 'capture' over 'list_trackers' or 'status', nor any context about prerequisites or typical scenarios for routing text input. Usage is implied but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List available trackers with their context types and status
| Name | Required | Description | Default |
|---|---|---|---|
| context | No | Filter by context type (business, personal, project, system) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While 'List' implies a read-only operation, it doesn't specify whether this requires authentication, has rate limits, returns paginated results, or what happens when no trackers exist. The description adds minimal behavioral context beyond the basic operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that states the core purpose without any unnecessary words. It's appropriately sized for a simple listing tool and front-loads the essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple listing tool with one optional parameter and no output schema, the description is minimally adequate. However, with no annotations and no output schema, it should ideally provide more context about what the returned data looks like and any behavioral constraints. The description covers the basic purpose but leaves gaps in behavioral transparency.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'context' clearly documented in the schema. The description doesn't add any parameter information beyond what's already in the schema, so it meets the baseline score of 3 when schema coverage is high.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('available trackers'), and specifies what information is returned ('with their context types and status'). However, it doesn't explicitly differentiate this listing tool from the 'capture' and 'status' sibling tools, which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 the 'capture' or 'status' tools. There's no mention of alternatives, prerequisites, or specific scenarios where this listing operation is appropriate versus other operations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get ChurnFlow system status and tracker information
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While 'Get' implies a read operation, the description doesn't specify whether this requires authentication, has rate limits, returns real-time vs cached data, or what format the information comes in. For a status-checking 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that states the core purpose without unnecessary words. It's appropriately sized for a simple status-checking tool and front-loads the essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter status tool with no output schema, the description provides the basic purpose but lacks important context. Without annotations or output schema, it should ideally specify what 'status and tracker information' includes, whether this is a health check or detailed metrics, and what format the response takes. The current description is minimally adequate but has clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the parameter situation. The description appropriately doesn't discuss parameters since none exist, earning a baseline 4 for not creating confusion about non-existent parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('ChurnFlow system status and tracker information'), making the purpose understandable. However, it doesn't explicitly differentiate this tool from its siblings 'capture' and 'list_trackers' - while 'list_trackers' seems related to tracker operations, the distinction isn't articulated in the description.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 siblings 'capture' and 'list_trackers'. There's no mention of appropriate contexts, prerequisites, or alternative tools for similar functionality, leaving the agent without usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0capturelist_trackersstatusEach tool has a clearly distinct purpose with no overlap: 'capture' handles input routing, 'list_trackers' enumerates available trackers, and 'status' provides system-level information. The descriptions clearly differentiate their functions, eliminating any ambiguity in tool selection.
The naming is mostly consistent with a verb_noun pattern ('list_trackers'), but 'capture' and 'status' are single-word verbs that deviate slightly. While readable and functional, this minor inconsistency prevents a perfect score.
With only 3 tools, the count feels thin for a system that appears to manage trackers and input routing, suggesting potential gaps in functionality. It's borderline for the apparent scope, as more operations (e.g., create/update/delete trackers) might be expected.
There are significant gaps in the tool surface for a tracker management system: it lacks CRUD operations for trackers (e.g., create, update, delete) and input handling beyond capture. This incomplete coverage could lead to agent failures when trying to perform basic lifecycle tasks.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
ADHD system of record for agents: tasks, goals, loops, calendar, focus stats.
Brain dump, routines, task planning, focus, and instant thought retrieval
AI-native project management for tasks, docs, collaboration, and agents.
AI-native project management + agent memory: tasks, sprints, risk, burnout, knowledge search.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/jgsteeler/churnflow-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
