MCP server
by cyberchitta
LLM Code Context boosts code reviews and documentation with smart file selection, code outlining, and multi-language sup
Provides smart file selection and code context management for sharing relevant project files with LLMs, avoiding token limits while ensuring complete coverage.
LLM Code Context is a community-built MCP server published by cyberchitta that provides AI assistants with tools and capabilities via the Model Context Protocol. LLM Code Context boosts code reviews and documentation with smart file selection, code outlining, and multi-language sup It is categorized under developer tools. This server exposes 4 tools that AI clients can invoke during conversations and coding sessions.
You can install LLM Code Context in your AI client of choice. Use the install panel on this page to get one-click setup for Cursor, Claude Desktop, VS Code, and other MCP-compatible clients. This server runs locally on your machine via the stdio transport.
Apache-2.0
LLM Code Context is released under the Apache-2.0 license. This is a permissive open-source license, meaning you can freely use, modify, and distribute the software.
Add new capabilities to Claude beyond text generation
Example
Access external data sources, execute code, interact with tools and services
Transform Claude from chatbot to action-taking agent
Provide Claude with access to relevant context and data
Example
Load project documentation, access knowledge bases, query databases
Get more accurate, context-aware responses
Automate multi-step workflows combining AI and external tools
Example
Research → Summarize → Create document → Send notification
Complete complex tasks end-to-end without manual steps
Share your MCP server with the developer community
LLM Code Context has been reliable for tool-calling workflows; the MCP profile page is a good permalink for internal docs.
Strong directory entry: LLM Code Context surfaces stars and publisher context so we could sanity-check maintenance before adopting.
LLM Code Context is among the better-indexed MCP projects we tried; the explainx.ai summary tracks the official description.
We wired LLM Code Context into a staging workspace; the listing’s GitHub and npm pointers saved time versus hunting across READMEs.
Useful MCP listing: LLM Code Context is the kind of server we cite when onboarding engineers to host + tool permissions.
LLM Code Context is a well-scoped MCP server in the explainx.ai directory — install snippets and categories matched our Claude Code setup.
We evaluated LLM Code Context against two servers with overlapping tools; this profile had the clearer scope statement.
LLM Code Context reduced integration guesswork — categories and install configs on the listing matched the upstream repo.
According to our notes, LLM Code Context benefits from clear Model Context Protocol framing — fewer ambiguous “AI plugin” claims.
I recommend LLM Code Context for teams standardizing on MCP; the explainx.ai page compares cleanly with sibling servers.
showing 1-10 of 74
Smart context management for LLM development workflows. Share relevant project files instantly through intelligent selection and rule-based filtering.
Getting the right context into LLM conversations is friction-heavy:
llm-context provides focused, task-specific project context through composable rules.
For humans using chat interfaces:
lc-select # Smart file selection
lc-context # Copy formatted context to clipboard
# Paste and work - AI can access additional files via MCP
For AI agents with CLI access:
lc-preview tmp-prm-auth # Validate rule selects right files
lc-context tmp-prm-auth # Get focused context for sub-agent
For AI agents in chat (MCP tools):
lc_outlines - Generate excerpted context from current rulelc_preview - Validate rule effectiveness before uselc_missing - Fetch specific files/implementations on demandNote: This project was developed in collaboration with several Claude Sonnets (3.5, 3.6, 3.7, 4.0) and Groks (3, 4), using LLM Context itself to share code during development. All code is heavily human-curated by @restlessronin.
uv tool install "llm-context>=0.6.0"
# One-time setup
cd your-project
lc-init
# Daily usage
lc-select
lc-context
# Paste into your LLM chat
Add to Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json):
{
"mcpServers": {
"llm-context": {
"command": "uvx",
"args": ["--from", "llm-context", "lc-mcp"]
}
}
}
Restart Claude Desktop. Now AI can access additional files during conversations without manual copying.
AI agents with shell access use llm-context to create focused contexts:
# Agent explores codebase
lc-outlines
# Agent creates focused rule for specific task
# (via Skill or lc-rule-instructions)
# Agent validates rule
lc-preview tmp-prm-oauth-task
# Agent uses context for sub-task
lc-context tmp-prm-oauth-task
AI agents in chat environments use MCP tools:
# Explore codebase structure
lc_outlines(root_path, rule_name)
# Validate rule effectiveness
lc_preview(root_path, rule_name)
# Fetch specific files/implementations
lc_missing(root_path, param_type, data, timestamp)
Rules are YAML+Markdown files that describe what context to provide for a task:
---
description: "Debug API authentication"
compose:
filters: [lc/flt-no-files]
excerpters: [lc/exc-base]
also-include:
full-files: ["/src/auth/**", "/tests/auth/**"]
---
Focus on authentication system and related tests.
prm-): Generate project contexts (e.g., lc/prm-developer)flt-): Control file inclusion (e.g., lc/flt-base, lc/flt-no-files)ins-): Provide guidelines (e.g., lc/ins-developer)sty-): Enforce coding standards (e.g., lc/sty-python)exc-): Configure content extraction (e.g., lc/exc-base)Build complex rules from simpler ones:
---
instructions: [lc/ins-developer, lc/sty-python]
compose:
filters: [lc/flt-base, project-filters]
excerpters: [lc/exc-base]
---
| Command | Purpose |
|---|---|
lc-init | Initialize project configuration |
lc-select | Select files based on current rule |
lc-context | Generate and copy context |
lc-context -p | Include prompt instructions |
lc-context -m | Format as separate message |
lc-context -nt | No tools (manual workflow) |
lc-set-rule <name> | Switch active rule |
lc-preview <rule> | Validate rule selection and size |
lc-outlines | Get code structure excerpts |
lc-missing | Fetch files/implementations (manual MCP) |
Let AI help create focused, task-specific rules. Two approaches depending on your environment:
How it works: Global skill guides you through creating rules interactively. Examines your codebase as needed using MCP tools.
Setup:
lc-init # Installs skill to ~/.claude/skills/
# Restart Claude Desktop or Claude Code
Usage:
# 1. Share project context
lc-context # Any rule - overview included
# 2. Paste into Claude, then ask:
# "Create a rule for refactoring authentication to JWT"
# "I need a rule to debug the payment processing"
Claude will:
lc-missing as neededtmp-prm-<task>.md)Skill documentation (progressively disclosed):
Skill.md - Quick workflow, decision patternsPATTERNS.md - Common rule patternsSYNTAX.md - Detailed referenceEXAMPLES.md - Complete walkthroughsTROUBLESHOOTING.md - Problem solvingHow it works: Load comprehensive rule-creation documentation into context, work with any LLM.
Usage:
# 1. Load framework
lc-set-rule lc/prm-rule-create
lc-select
lc-context -nt
# 2. Paste into any LLM
# "I need a rule for adding OAuth integration"
# 3. LLM generates focused rule using framework
# 4. Use the new rule
lc-set-rule tmp-prm-oauth
lc-select
lc-context
Included documentation:
lc/ins-rule-intro - Introduction and overviewlc/ins-rule-framework - Complete decision framework| Aspect | Skill | Instruction Rules |
|---|---|---|
| Setup | Automatic with lc-init | Already available |
| Interaction | Interactive, uses lc-missing | Static documentation |
| File examination | Automatic via MCP | Manual or via AI |
| Best for | Claude Desktop/Code | Any LLM, any environment |
| Updates | Automatic with version upgrades | Built-in to rules |
Both require sharing project context first. Both produce equivalent results.
cat > .llm-context/rules/flt-repo-base.md << 'EOF'
---
description: "Repository-specific exclusions"
compose:
filters: [lc/flt-base]
gitignores:
full-files: ["*.md", "/tests", "/node_modules"]
excerpted-files: ["*.md", "/tests"]
---
EOF
cat > .llm-context/rules/prm-code.md << 'EOF'
---
description: "Main development rule"
instructions: [lc/ins-developer, lc/sty-python]
compose:
filters: [flt-repo-base]
excerpters: [lc/exc-base]
---
Additional project-specific guidelines and context.
EOF
lc-set-rule prm-code
Choose format based on your LLM environment:
| Pattern | Command | Use Case |
|---|---|---|
| System Message | lc-context -p | AI Studio, etc. |
| Single User Message | lc-context -p -m | Grok, etc. |
| Separate Messages | lc-prompt + lc-context -m | Flexible placement |
| Project Files (included) | lc-context | Claude Projects, etc. |
| Project Files (searchable) | lc-context -m | Force into context |
See Deployment Patterns for details.
lc-set-rule prm-code
lc-select
lc-context
# Paste into chat - AI accesses more files via MCP if needed
# Share project context first
lc-context
# Then create focused rule:
# Via Skill: "Create a rule for [task]"
# Via Instructions: lc-set-rule lc/prm-rule-create && lc-context -nt
# Validate and use
lc-preview tmp-prm-task
lc-context tmp-prm-task
# Agent validates rule effectiveness
lc-preview tmp-prm-refactor-auth
# Agent generates context for sub-agent
lc-context tmp-prm-refactor-auth > /tmp/context.md
# Sub-agent reads context and executes task
# Agent validates rule
preview
---
Prerequisites
Time Estimate
15-60 minutes depending on server complexity
Steps
Troubleshooting
✓ Do
✗ Don't
💡 Pro Tips
Architecture
Model Context Protocol standardizes how AI hosts (Claude, Cursor) communicate with external tools and data sources through server implementations.
Protocols
Compatibility
✓ Use when
Use when you need Claude to access external data, execute actions, or integrate with tools. Best for extending AI capabilities beyond conversation.
✗ Avoid when
Avoid when native integrations exist (use official APIs directly), for real-time critical systems, or when security/compliance requires zero external dependencies.