Using Skill Seekers with Continue.dev

Using Skill Seekers with Continue.dev

Last Updated: February 7, 2026 Status: Production Ready Difficulty: Easy ⭐

🎯 The Problem

Continue.dev is a powerful IDE-agnostic AI coding assistant, but:

• Generic Knowledge - AI doesn't know your project-specific frameworks or patterns
• Manual Context - Typing @-mentions for every framework detail is tedious
• Multi-IDE Consistency - Context varies between VS Code, JetBrains, and other IDEs
• Limited Built-in Providers - Few pre-configured documentation sources

Example:

"When using Continue in VS Code and JetBrains simultaneously, you want consistent framework knowledge across both IDEs without manual setup duplication. Continue's built-in @docs provider requires manual indexing."

✨ The Solution

Use Skill Seekers to create custom context providers for Continue.dev:

1. Generate structured docs from any framework or codebase
2. Package as HTTP context provider - Continue's universal format
3. MCP Integration - Expose documentation via Model Context Protocol
4. IDE-Agnostic - Same context in VS Code, JetBrains, and future IDEs

Result: Continue becomes an expert in your frameworks across all IDEs with consistent, automatic context.

🚀 Quick Start (5 Minutes)

Prerequisites

• Continue.dev installed in your IDE:
  • VS Code: https://marketplace.visualstudio.com/items?itemName=Continue.continue
  • JetBrains: Settings → Plugins → Search "Continue"
• Python 3.10+ (for Skill Seekers)

Installation

# Install Skill Seekers with MCP support
pip install skill-seekers[mcp]

# Verify installation
skill-seekers --version

Generate Documentation

# Example: Vue.js framework
skill-seekers scrape --config configs/vue.json

# Package for Continue (markdown format)
skill-seekers package output/vue --target markdown

# Extract documentation
# output/vue-markdown/SKILL.md

Setup in Continue.dev

Option 1: Custom Context Provider (recommended)

Edit ~/.continue/config.json:

{
  "contextProviders": [
    {
      "name": "http",
      "params": {
        "url": "http://localhost:8765/docs/vue",
        "title": "vue-docs",
        "displayTitle": "Vue.js Documentation",
        "description": "Vue.js framework expert knowledge"
      }
    }
  ]
}

Option 2: MCP Server (for dynamic access)

# Start Skill Seekers MCP server
skill-seekers mcp-server --port 8765

# Or as systemd service (Linux)
sudo systemctl enable skill-seekers-mcp
sudo systemctl start skill-seekers-mcp

Add to ~/.continue/config.json:

{
  "mcpServers": {
    "skill-seekers": {
      "command": "python",
      "args": ["-m", "skill_seekers.mcp.server_fastmcp", "--transport", "stdio"]
    }
  }
}

Option 3: Built-in @docs Provider

{
  "contextProviders": [
    {
      "name": "docs",
      "params": {
        "sites": [
          {
            "title": "Vue.js",
            "startUrl": "https://vuejs.org/guide/",
            "rootUrl": "https://vuejs.org/"
          }
        ]
      }
    }
  ]
}

Test in Continue

1. Open any project in your IDE
2. Open Continue panel (Cmd+L or Ctrl+L)
3. Type @ and select your context provider:

   @vue-docs Create a Vue 3 component with Composition API
   

4. Verify Continue references your documentation

📖 Detailed Setup Guide

Step 1: Choose Your Documentation Source

Option A: Use Preset Configs (24+ frameworks)

# List available presets
ls configs/

# Popular presets:
# - react.json, vue.json, angular.json (Frontend)
# - django.json, fastapi.json, flask.json (Backend)
# - kubernetes.json, docker.json (Infrastructure)

Option B: Custom Documentation

Create myframework-config.json:

{
  "name": "myframework",
  "description": "Custom framework documentation for Continue.dev",
  "base_url": "https://docs.myframework.com/",
  "selectors": {
    "main_content": "article",
    "title": "h1",
    "code_blocks": "pre code"
  },
  "categories": {
    "getting_started": ["intro", "quickstart"],
    "core_concepts": ["concepts", "architecture"],
    "api": ["api", "reference"],
    "best_practices": ["best-practices", "patterns"]
  }
}

Option C: GitHub Repository

# Analyze codebase patterns
skill-seekers github --repo facebook/react

# Or local codebase
skill-seekers analyze --directory /path/to/repo --comprehensive

Step 2: Optimize for Continue.dev

HTTP Context Provider

Continue supports HTTP-based context providers for maximum flexibility:

# custom_context_server.py
from fastapi import FastAPI
from skill_seekers.cli.doc_scraper import load_skill

app = FastAPI()

# Load documentation
vue_docs = load_skill("output/vue-markdown/SKILL.md")

@app.get("/docs/{framework}")
async def get_framework_docs(framework: str, query: str = None):
    """
    Return framework documentation as context.

    Args:
        framework: Framework name (vue, react, django, etc.)
        query: Optional search query for filtering

    Returns:
        Context items for Continue.dev
    """
    if query:
        # Filter by query
        filtered = search_docs(vue_docs, query)
        content = "\n\n".join(filtered)
    else:
        # Return full docs
        content = vue_docs

    return {
        "contextItems": [
            {
                "name": f"{framework.title()} Documentation",
                "description": f"Complete {framework} framework knowledge",
                "content": content
            }
        ]
    }

# Run with: uvicorn custom_context_server:app --port 8765

MCP Context Provider

For advanced users, expose via MCP:

{
  "contextProviders": [
    {
      "name": "mcp",
      "params": {
        "serverName": "skill-seekers",
        "contextItem": {
          "type": "docs",
          "name": "Framework Documentation"
        }
      }
    }
  ],
  "mcpServers": {
    "skill-seekers": {
      "command": "python",
      "args": ["-m", "skill_seekers.mcp.server_fastmcp", "--transport", "stdio"]
    }
  }
}

Built-in @docs Provider

Simplest approach for public documentation:

{
  "contextProviders": [
    {
      "name": "docs",
      "params": {
        "sites": [
          {
            "title": "Vue.js",
            "startUrl": "https://vuejs.org/guide/",
            "rootUrl": "https://vuejs.org/"
          },
          {
            "title": "Pinia",
            "startUrl": "https://pinia.vuejs.org/",
            "rootUrl": "https://pinia.vuejs.org/"
          }
        ]
      }
    }
  ]
}

Step 3: Configure for Multiple IDEs

VS Code Configuration

Location: ~/.continue/config.json (global) or .vscode/continue.json (project)

{
  "models": [
    {
      "title": "Claude Sonnet 4.5",
      "provider": "anthropic",
      "model": "claude-sonnet-4-5-20250929",
      "apiKey": "${ANTHROPIC_API_KEY}"
    }
  ],
  "contextProviders": [
    {
      "name": "http",
      "params": {
        "url": "http://localhost:8765/docs/vue",
        "title": "vue-docs",
        "displayTitle": "Vue.js Docs",
        "description": "Vue.js framework knowledge"
      }
    }
  ]
}

JetBrains Configuration

Location: ~/.continue/config.json (same file!)

Continue.dev uses the SAME config file across all IDEs:

# Edit once, works everywhere
vim ~/.continue/config.json

# Test in VS Code
code my-vue-project/

# Test in IntelliJ IDEA
idea my-vue-project/

# Same context providers in both!

Per-Project Configuration

# Create project-specific config
mkdir -p /path/to/project/.continue
cp ~/.continue/config.json /path/to/project/.continue/config.json

# Edit for project needs
vim /path/to/project/.continue/config.json

# Add project-specific context:
{
  "contextProviders": [
    {
      "name": "http",
      "params": {
        "url": "http://localhost:8765/docs/vue",
        "title": "vue-docs"
      }
    },
    {
      "name": "http",
      "params": {
        "url": "http://localhost:8765/project/conventions",
        "title": "project-conventions",
        "displayTitle": "Project Conventions",
        "description": "Company-specific patterns"
      }
    }
  ]
}

Step 4: Test and Refine

Test Context Access

In Continue panel:

@vue-docs Show me how to create a Vue 3 component with Composition API and TypeScript

Expected: Continue references your documentation, shows correct patterns

Verify Multi-IDE Consistency

# Open same project in VS Code
code my-project/
# Type: @vue-docs Create a component
# Note the response

# Open same project in IntelliJ
idea my-project/
# Type: @vue-docs Create a component
# Response should be IDENTICAL

Monitor Context Usage

Check Continue logs:

# VS Code
Cmd+Shift+P → "Continue: Show Logs"

# JetBrains
Tools → Continue → Show Logs

# Look for:
# "Loaded context from http://localhost:8765/docs/vue"
# "Context items: 1, tokens: 5420"

🎨 Advanced Usage

Multi-Framework Projects

Full-Stack Vue + FastAPI

# Generate frontend context
skill-seekers scrape --config configs/vue.json
# Generate backend context
skill-seekers scrape --config configs/fastapi.json

# Start context server with both
python custom_multi_context_server.py

custom_multi_context_server.py:

from fastapi import FastAPI
from skill_seekers.cli.doc_scraper import load_skill

app = FastAPI()

# Load multiple frameworks
vue_docs = load_skill("output/vue-markdown/SKILL.md")
fastapi_docs = load_skill("output/fastapi-markdown/SKILL.md")

@app.get("/docs/{framework}")
async def get_docs(framework: str):
    docs = {
        "vue": vue_docs,
        "fastapi": fastapi_docs
    }

    if framework not in docs:
        return {"error": "Framework not found"}

    return {
        "contextItems": [
            {
                "name": f"{framework.title()} Documentation",
                "description": f"Expert knowledge for {framework}",
                "content": docs[framework]
            }
        ]
    }

Continue config:

{
  "contextProviders": [
    {
      "name": "http",
      "params": {
        "url": "http://localhost:8765/docs/vue",
        "title": "vue-docs",
        "displayTitle": "Vue.js Frontend"
      }
    },
    {
      "name": "http",
      "params": {
        "url": "http://localhost:8765/docs/fastapi",
        "title": "fastapi-docs",
        "displayTitle": "FastAPI Backend"
      }
    }
  ]
}

Now use both:

@vue-docs @fastapi-docs Create a full-stack feature:
- Vue component for user registration
- FastAPI endpoint with validation
- Database model with SQLAlchemy

Dynamic Context with RAG

Combine with Vector Search

# rag_context_server.py
from fastapi import FastAPI
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
from skill_seekers.cli.package_skill import main as package

app = FastAPI()

# Load RAG pipeline
embeddings = OpenAIEmbeddings()
vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=embeddings)

@app.get("/docs/search")
async def search_docs(query: str, k: int = 5):
    """
    Search documentation using RAG.

    Args:
        query: Search query
        k: Number of results

    Returns:
        Top-k relevant snippets as context
    """
    results = vectorstore.similarity_search(query, k=k)

    return {
        "contextItems": [
            {
                "name": f"Result {i+1}",
                "description": doc.metadata.get("source", "Documentation"),
                "content": doc.page_content
            }
            for i, doc in enumerate(results)
        ]
    }

Continue config:

{
  "contextProviders": [
    {
      "name": "http",
      "params": {
        "url": "http://localhost:8765/docs/search?query={query}",
        "title": "rag-search",
        "displayTitle": "RAG Search",
        "description": "Search all documentation"
      }
    }
  ]
}

TypeScript Custom Context Provider

For Advanced Customization

Create ~/.continue/context/custom-rag.ts:

import { ContextProvider, ContextItem } from "@continuedev/core";

class CustomRAGProvider implements ContextProvider {
  title = "rag";
  displayTitle = "RAG Search";
  description = "Search internal documentation";

  async getContextItems(
    query: string,
    extras: any
  ): Promise<ContextItem[]> {
    // Query your RAG pipeline
    const response = await fetch(
      `http://localhost:8765/docs/search?query=${encodeURIComponent(query)}`
    );

    const data = await response.json();

    return data.contextItems.map((item: any) => ({
      name: item.name,
      description: item.description,
      content: item.content,
    }));
  }
}

export default CustomRAGProvider;

Register in config.json:

{
  "contextProviders": [
    {
      "name": "custom",
      "params": {
        "modulePath": "~/.continue/context/custom-rag.ts"
      }
    }
  ]
}

Continue + Skill Seekers MCP Integration

Full MCP Setup

# Install Skill Seekers with MCP
pip install skill-seekers[mcp]

# Start MCP server
python -m skill_seekers.mcp.server_fastmcp --transport stdio

Continue config with MCP:

{
  "mcpServers": {
    "skill-seekers": {
      "command": "python",
      "args": [
        "-m",
        "skill_seekers.mcp.server_fastmcp",
        "--transport",
        "stdio"
      ],
      "env": {
        "ANTHROPIC_API_KEY": "${env:ANTHROPIC_API_KEY}"
      }
    }
  },
  "contextProviders": [
    {
      "name": "mcp",
      "params": {
        "serverName": "skill-seekers",
        "contextItem": {
          "type": "docs",
          "name": "Framework Documentation"
        }
      }
    }
  ]
}

Now Continue can:

• Query documentation via MCP
• Scrape docs on-demand
• Package skills dynamically

💡 Best Practices

1. Use IDE-Agnostic Configuration

Bad: Duplicate Configs

# Different configs for each IDE
~/.continue/vscode-config.json
~/.continue/jetbrains-config.json
~/.continue/vim-config.json

Good: Single Source of Truth

# One config for all IDEs
~/.continue/config.json

# Continue automatically loads from here in:
# - VS Code
# - JetBrains (IntelliJ, PyCharm, WebStorm)
# - Vim/Neovim (with Continue plugin)

2. Organize Context Providers

{
  "contextProviders": [
    // Core frameworks (always needed)
    {
      "name": "http",
      "params": {
        "url": "http://localhost:8765/docs/vue",
        "title": "vue-core",
        "displayTitle": "Vue.js Core"
      }
    },
    // Ecosystem libraries (optional)
    {
      "name": "http",
      "params": {
        "url": "http://localhost:8765/docs/pinia",
        "title": "pinia",
        "displayTitle": "Pinia State Management"
      }
    },
    // Project-specific (highest priority)
    {
      "name": "http",
      "params": {
        "url": "http://localhost:8765/project/conventions",
        "title": "conventions",
        "displayTitle": "Project Conventions"
      }
    }
  ]
}

3. Cache Documentation Locally

# cached_context_server.py
from fastapi import FastAPI
from functools import lru_cache
import hashlib

app = FastAPI()

@lru_cache(maxsize=100)
def get_cached_docs(framework: str) -> str:
    """Cache documentation in memory."""
    return load_skill(f"output/{framework}-markdown/SKILL.md")

@app.get("/docs/{framework}")
async def get_docs(framework: str):
    # Returns cached version (fast!)
    content = get_cached_docs(framework)

    return {
        "contextItems": [{
            "name": f"{framework.title()} Docs",
            "content": content
        }]
    }

4. Use Environment Variables

{
  "models": [
    {
      "title": "Claude Sonnet",
      "provider": "anthropic",
      "model": "claude-sonnet-4-5-20250929",
      "apiKey": "${ANTHROPIC_API_KEY}"  // From environment
    }
  ],
  "contextProviders": [
    {
      "name": "http",
      "params": {
        "url": "${CONTEXT_SERVER_URL}/docs/vue",  // Configurable
        "title": "vue-docs"
      }
    }
  ]
}

5. Update Documentation Regularly

# Quarterly update script
#!/bin/bash

# Update Vue docs
skill-seekers scrape --config configs/vue.json
skill-seekers package output/vue --target markdown

# Update FastAPI docs
skill-seekers scrape --config configs/fastapi.json
skill-seekers package output/fastapi --target markdown

# Restart context server
systemctl restart skill-seekers-context-server

echo "✅ Documentation updated!"

🔥 Real-World Examples

Example 1: Vue.js Full-Stack Development

Project Structure:

my-vue-app/
├── .continue/
│   └── config.json           # Project-specific Continue config
├── frontend/                 # Vue 3 app
└── backend/                  # FastAPI server

.continue/config.json:

{
  "models": [
    {
      "title": "Claude Sonnet",
      "provider": "anthropic",
      "model": "claude-sonnet-4-5-20250929",
      "apiKey": "${ANTHROPIC_API_KEY}"
    }
  ],
  "contextProviders": [
    {
      "name": "http",
      "params": {
        "url": "http://localhost:8765/docs/vue",
        "title": "vue-docs",
        "displayTitle": "Vue.js 3",
        "description": "Vue 3 Composition API patterns"
      }
    },
    {
      "name": "http",
      "params": {
        "url": "http://localhost:8765/docs/pinia",
        "title": "pinia-docs",
        "displayTitle": "Pinia",
        "description": "State management patterns"
      }
    },
    {
      "name": "http",
      "params": {
        "url": "http://localhost:8765/docs/fastapi",
        "title": "fastapi-docs",
        "displayTitle": "FastAPI",
        "description": "Backend API patterns"
      }
    }
  ]
}

Using in Continue (Any IDE):

In Continue panel:

@vue-docs @pinia-docs Create a Vue component:
- User profile display
- Load data from Pinia store
- Composition API with TypeScript
- Responsive design

Continue will:
1. ✅ Use Composition API (from vue-docs)
2. ✅ Access Pinia store correctly (from pinia-docs)
3. ✅ Add TypeScript types (from vue-docs)
4. ✅ Follow Vue 3 best practices

Then:

@fastapi-docs Create backend endpoint:
- GET /api/v1/users/:id
- Async database query
- Pydantic response model

Continue will:
1. ✅ Use async/await (from fastapi-docs)
2. ✅ Dependency injection (from fastapi-docs)
3. ✅ Pydantic models (from fastapi-docs)

Example 2: Multi-IDE Consistency

Scenario: Team uses different IDEs

Team Members:

• Alice: VS Code
• Bob: IntelliJ IDEA
• Charlie: PyCharm

Setup (Once):

# 1. Generate documentation
skill-seekers scrape --config configs/django.json
skill-seekers package output/django --target markdown

# 2. Start context server (team server)
python context_server.py --host 0.0.0.0 --port 8765

# 3. Share config (Git repository)
cat > .continue/config.json << 'EOF'
{
  "contextProviders": [
    {
      "name": "http",
      "params": {
        "url": "http://team-server:8765/docs/django",
        "title": "django-docs",
        "displayTitle": "Django",
        "description": "Team Django patterns"
      }
    }
  ]
}
EOF

git add .continue/config.json
git commit -m "Add Continue.dev configuration"
git push

Result:

• ✅ Alice (VS Code) gets Django patterns
• ✅ Bob (IntelliJ) gets SAME Django patterns
• ✅ Charlie (PyCharm) gets SAME Django patterns
• ✅ One config file, three IDEs, consistent AI suggestions

🐛 Troubleshooting

Issue: Context Provider Not Loading

Symptoms:

• @mention doesn't show your provider
• Continue ignores documentation

Solutions:

1. Check config location

   # Global config
   cat ~/.continue/config.json
   
   # Project config (takes precedence)
   cat .continue/config.json
   
   # Verify contextProviders array exists
   

2. Verify HTTP server is running

   curl http://localhost:8765/docs/vue
   
   # Should return JSON with contextItems
   

3. Check Continue logs

   VS Code: Cmd+Shift+P → "Continue: Show Logs"
   JetBrains: Tools → Continue → Show Logs
   
   Look for errors like:
   "Failed to load context from http://localhost:8765/docs/vue"
   

4. Reload Continue

   VS Code: Cmd+Shift+P → "Developer: Reload Window"
   JetBrains: File → Invalidate Caches → Restart
   

Issue: MCP Server Not Connecting

Error:

"Failed to start MCP server: skill-seekers"

Solutions:

1. Verify installation

   pip show skill-seekers
   # Check [mcp] extra is installed
   

2. Test MCP server directly

   python -m skill_seekers.mcp.server_fastmcp --transport stdio
   # Should start without errors
   # Ctrl+C to exit
   

3. Check Python path

   {
     "mcpServers": {
       "skill-seekers": {
         "command": "/usr/local/bin/python3",  // Absolute path
         "args": ["-m", "skill_seekers.mcp.server_fastmcp", "--transport", "stdio"]
       }
     }
   }
   

4. Check environment variables

   echo $ANTHROPIC_API_KEY
   # Should be set for AI enhancement features
   

Issue: Different Results in Different IDEs

Symptoms:

• VS Code suggestions differ from JetBrains
• Context inconsistent across IDEs

Solutions:

1. Use same config file

   # Ensure both IDEs use ~/.continue/config.json
   # NOT project-specific configs
   
   # Check VS Code
   ls ~/.continue/config.json
   
   # Check JetBrains (uses same file!)
   ls ~/.continue/config.json
   

2. Verify context server URL

   # Must be accessible from all IDEs
   # Use localhost or team server IP
   
   # Test from both IDEs:
   curl http://localhost:8765/docs/vue
   

3. Clear Continue cache

   # Remove cached context
   rm -rf ~/.continue/cache/
   
   # Restart IDEs
   

📊 Before vs After Comparison

🤝 Community & Support

• Questions: GitHub Discussions
• Issues: GitHub Issues
• Website: skillseekersweb.com
• Continue.dev Docs: docs.continue.dev
• Continue.dev GitHub: github.com/continuedev/continue

📚 Related Guides

• Cursor Integration - IDE-specific approach
• Windsurf Integration - Alternative IDE
• Cline Integration - VS Code extension with MCP
• LangChain Integration - Build RAG pipelines
• Context Providers Reference

📖 Next Steps

1. Try another framework: skill-seekers scrape --config configs/react.json
2. Set up team server: Share context across team
3. Build RAG pipeline: Deep search with --target langchain
4. Create custom TypeScript provider: Advanced customization
5. Multi-IDE setup: Test consistency across VS Code + JetBrains

Sources:

• Continue.dev Documentation
• config.json Reference
• Context Providers Guide
• MCP with Continue.dev
• Continue.dev Configuration Guide
• MCP Server Implementation Guide