The Problem

Every time you start a new conversation with your AI copilot, it forgets everything.

• 🔄 You repeat the same context about your project, your team, your standards
• 🤷 The copilot makes mistakes you've already corrected in past sessions
• 📄 Your policies, specs, and business rules sit in files the copilot never sees
• 🧠 Decisions and rationale from past conversations are lost forever

Copilots are powerful — but they have amnesia.

The Solution

Kahuna gives your copilot a persistent memory that grows smarter over time.

How it works: Kahuna runs as an MCP server alongside your copilot. You teach it your context once — policies, specs, decisions, patterns — and it proactively surfaces the right knowledge for each task.

🔒 All data stays local. Your code and context never leave your machine.

Quickstart (Claude Code)

Step 1: Add Kahuna to Claude Code

claude mcp add kahuna -s user -e ANTHROPIC_API_KEY="your-anthropic-api-key" -- npx @aurite-ai/kahuna

Scope options:

• -s project — Config stored for current project only
• -s user — Config stored globally (available across all projects)

Step 2: In any project, tell your copilot:

"Set up Kahuna"

This deploys copilot rules and runs onboarding. The copilot asks a few questions to understand your context — this only happens once.

Step 3: Start teaching it your context:

"learn ~/Downloads/api-guidelines.pdf"

"learn the docs/ folder"

Step 4: Start working — Kahuna surfaces the right context automatically.

"build a customer support agent"

Kahuna feeds your copilot your API conventions, auth patterns, and related context. No reminders needed.

npm install -g @aurite-ai/kahuna

npx @aurite-ai/kahuna

docker pull kahuna/mcp
docker run -i kahuna/mcp

git clone https://github.com/Aurite-ai/kahuna.git
cd kahuna
pnpm install
pnpm --filter @aurite-ai/kahuna build
pnpm --filter @aurite-ai/kahuna bundle

What It Looks Like

You teach Kahuna your company's context:

"learn ~/docs/api-guidelines.pdf"

"learn the docs/ folder"

Later, you start a task:

"build a customer support agent"

Kahuna automatically surfaces the relevant context to your copilot:

• ✅ Your API conventions and auth patterns
• ✅ Customer data models and access policies
• ✅ Error handling and response format standards
• ✅ Related endpoints already in the codebase

Your copilot builds it right the first time — no reminders needed.

How It Works

┌─────────────────────────────────────────────────────────────────┐
│  YOU                          COPILOT                  KAHUNA   │
│                                                                 │
│  "set up Kahuna"  ─────────►  deploys rules  ─────►  .claude/   │
│                               asks questions          stores    │
│                                                       context   │
│                                                                 │
│  "learn these docs" ───────►  kahuna_learn   ─────►  knowledge  │
│                                                       base      │
│                                                                 │
│  "build feature X" ────────►  kahuna_prepare ─────►  surfaces   │
│                               _context                relevant  │
│                                                       files     │
└─────────────────────────────────────────────────────────────────┘

💡 If Kahuna saves you from repeating yourself, consider giving it a ⭐. It helps others discover the project.

Contents

• The Problem
• The Solution
• Quickstart
• What It Looks Like
• How It Works
• How It Compares
• Features
• Available Tools
• Documentation
• Contributing
• License

How It Compares

Kahuna is not a replacement for built-in copilot memory — it's what copilot memory should have been.

Features

• 🧠 Knowledge Base — Store, categorize, and retrieve context from markdown files
• 🎯 Smart Context Surfacing — Automatically surface relevant knowledge for your task
• 🔗 Integration Management — Discover, verify, and use external service integrations
• 🔐 Secure Credential Vault — Store and manage secrets with multiple provider support
• 📊 Usage Tracking — Monitor token consumption and costs per project
• 🚀 Onboarding System — Guided setup for organization and project context

Available Tools

Documentation

For Users:

• MCP Server Documentation — Installation, tools, configuration
• Advanced Documentation — Integrations, vault, KB structure

For Contributors:

• Product Design — Core concepts, tool specifications
• Architecture: Repository Infrastructure
• Architecture: Context Management System

Contributing

We welcome contributions of all kinds!

• 🐛 Found a bug? Open an issue
• 💡 Have an idea? Open a feature request
• 🔧 Want to contribute code? Open a PR

# Install dependencies
pnpm install

# Set up environment
cp apps/mcp/.env.example apps/mcp/.env

# Build workspace packages
pnpm build

# Run tests
pnpm test

kahuna/
├── apps/
│   └── mcp/                # MCP server (stdio) — context management tools
│       ├── src/
│       │   ├── knowledge/  # Knowledge base domain logic (agents, storage, surfacing)
│       │   ├── integrations/   # External service integration management
│       │   ├── vault/      # Secure credential management
│       │   ├── usage/      # Token usage and cost tracking
│       │   └── tools/      # MCP tool handlers
│       └── templates/      # Project initialization templates
├── packages/
│   ├── testing/            # QA testing infrastructure (scenarios + CLI)
│   └── vck-templates/      # Copilot configuration templates
└── docs/                   # Documentation

License

MIT