MCP Server for Claude Code

AwesomeContext

Compress engineering rules into latent space tensors.
Query them in milliseconds.

0
Modules
<5ms
Retrieval
0%
Token Savings
Get StartedView Tools

How It Works

Three steps to inject compressed engineering rules into every Claude conversation.

Step 01

Configure

Add the AwesomeContext MCP server URL to your Claude Code settings. One line of JSON — that's it.

// .claude/settings.json
{
  "mcpServers": {
    "awesome-context": {
      "url": "https://your-domain.com/mcp"
    }
  }
}
Step 02

Query

Claude automatically calls get_rules at the start of every session, loading project-specific coding standards, security rules, and best practices.

// Auto-invoked by Claude
tools/call: get_rules
{
  "project_type": "react"
}
// → Returns 5 matched rules
//   in < 5ms
Step 03

Inject

Compressed rules flow into Claude's context as dense prompts — 96% fewer tokens than raw markdown, with zero loss of instruction quality.

// Claude's context receives:
# Active Rules for: react

## Coding Rules
- Component patterns...
- Testing standards...
- Security guidelines...

// 150 tokens vs 4,000+

MCP Tools

Four specialized tools that Claude calls automatically during development.

get_rulesAuto-invoked

Loads project-specific coding standards, security guidelines, and best practices at the start of every conversation.

Parameters
project_typestring— Tech stack identifier (e.g. react, python, golang)
{
  "tool": "get_rules",
  "arguments": {
    "project_type": "typescript"
  }
}

// Returns: 5 matched rules
// Tokens: ~150 (vs 4,000+ raw)
architect_consultBefore coding

Retrieves architecture patterns, design principles, and domain-specific guidance before writing any code.

Parameters
intentstring— Design question or task description
top_knumber— Number of modules to retrieve (1-10)
{
  "tool": "architect_consult",
  "arguments": {
    "intent": "design a REST API
      with auth and rate limiting",
    "top_k": 5
  }
}
skill_injectorOn demand

Loads full implementation details for specific skills — security reviews, TDD workflows, database patterns, and more.

Parameters
skill_idstring— Skill path (e.g. skills/security-review)
{
  "tool": "skill_injector",
  "arguments": {
    "skill_id": "skills/security-review"
  }
}

// Returns: Full security review
// checklist and procedures
compliance_verifyBefore commit

Checks code against loaded rules for compliance violations, security issues, and anti-patterns before committing.

Parameters
codestring— Code snippet or diff to verify
{
  "tool": "compliance_verify",
  "arguments": {
    "code": "def get_user(id):
      query = f'SELECT * FROM
        users WHERE id={id}'
      ..."
  }
}
// → Flags SQL injection risk

Examples

See how Claude interacts with AwesomeContext during real development workflows.

Ask Claude to design a system — it automatically consults the latent knowledge base for architecture patterns.

Request
// You say to Claude:
"Design a REST API with authentication
 and rate limiting for our Next.js app"

// Claude auto-calls:
tools/call: architect_consult
{
  "intent": "REST API design with auth
    and rate limiting for Next.js",
  "top_k": 5
}
Response
// AwesomeContext returns (< 5ms):
{
  "dense_prompt": "API Design Rules:
    1. Use layered architecture
       (controller → service → repo)
    2. JWT + refresh token rotation
    3. Rate limit: sliding window,
       429 with Retry-After header
    4. Input validation at boundary
    5. OpenAPI spec-first design...",
  "metrics": {
    "tokens_saved": 3847,
    "retrieval_time_ms": 1.2,
    "modules_matched": 5
  }
}

Quick Start

Start using AwesomeContext in under a minute. Choose cloud or self-hosted.

Cloud

Recommended

No installation needed. Add the MCP server URL to your Claude Code settings and start coding.

1. Add to Claude Code settings
// .claude/settings.json
{
  "mcpServers": {
    "awesome-context": {
      "url": "https://api.awesomecontext.awareness.market/mcp"
    }
  }
}
2. Start coding

Claude will automatically call get_rules when you start a new session. Rules are injected based on your project type.

Self-Hosted

Full control

Run the complete stack locally or on your own infrastructure. Customize rules and add your own modules.

1. Clone and build
git clone https://github.com/
  everest-an/AwesomeContext.git
cd AwesomeContext
docker compose --profile cloud up -d
2. Configure Claude Code
// .claude/settings.json
{
  "mcpServers": {
    "awesome-context": {
      "url": "http://localhost:3000/mcp"
    }
  }
}
3. Add custom rules (optional)

Drop markdown files into vendor/ and rebuild to add your own engineering rules and skills.

Optional: Auto-Invocation with CLAUDE.md

For the best experience, add a CLAUDE.md file to your project root. This tells Claude to always invoke AwesomeContext tools at the right moments.

# CLAUDE.md

## MCP Tools — Auto-Invocation Rules

ALWAYS call these tools from the "awesome-context" MCP server:

1. **get_rules** — Call at the START of every conversation
   with project_type matching this project's stack.

2. **architect_consult** — Call BEFORE writing any code.
   Pass your design intent as the "intent" parameter.

3. **compliance_verify** — Call BEFORE committing code.
   Pass the code diff as the "code" parameter.