### Install Dependencies with uv

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/CLAUDE.md

Installs all project dependencies, including extras, using the uv package manager. This command ensures the development environment is set up correctly.

```bash
uv sync --all-extras
```

--------------------------------

### Running the Server (Bash)

Source: https://context7.com/ramalamadingdong/agentic-csa/llms.txt

These commands demonstrate how to install and run the Agentic CSA server using `uv` and `uvx`. It covers installation via pip, direct execution, running via `uvx`, and running from source.

```bash
# Install with uv
uv pip install first-agentic-csa

# Run the server (stdio transport for MCP)
first-agentic-csa

# Or run via uvx directly
uvx first-agentic-csa

# Run from source with uv
uv run first-agentic-csa
```

--------------------------------

### Programmatic Server Startup (Python)

Source: https://context7.com/ramalamadingdong/agentic-csa/llms.txt

This Python code shows how to start the Agentic CSA server programmatically using the `asyncio` library. It includes options for running the server directly in a blocking manner or initializing it manually for custom server setups.

```python
# Programmatic server startup
import asyncio
from wpilib_mcp.server import run_server, initialize_server, create_server

# Run server (blocking)
asyncio.run(run_server())

# Or initialize manually for custom setup
async def custom_setup():
    await initialize_server()  # Loads plugins
    server = create_server()   # Creates MCP server instance
    # ... custom transport setup
```

--------------------------------

### Run Local Server

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/CLAUDE.md

Starts the FIRST Agentic CSA server locally using the uv run command. This allows for local development and testing of the server's functionality.

```bash
uv run first-agentic-csa
```

--------------------------------

### Install uv Package Manager

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/README.md

Instructions for installing the 'uv' package manager, a prerequisite for the FIRST Agentic CSA. This tool is used for managing Python packages and executing commands.

```bash
pip install uv
```

--------------------------------

### Build Documentation Indexes

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/CLAUDE.md

Scripts to build documentation indexes for various vendors and versions. These indexes are used by the search functionality.

```bash
python scripts/build_index.py all
python scripts/build_index.py wpilib --version 2025
python scripts/build_index.py rev
```

--------------------------------

### Build Package

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/CLAUDE.md

Builds the project package using uv. This command is used to create distributable artifacts of the project.

```bash
uv build
```

--------------------------------

### Run Tests with pytest

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/CLAUDE.md

Executes the project's test suite using pytest, with verbose output enabled. This command is crucial for verifying the functionality and stability of the codebase.

```bash
uv run pytest tests/ -v
```

--------------------------------

### Async Fetch Page Function Signature

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/CLAUDE.md

Defines the asynchronous function signature for fetching a single documentation page. It takes a URL and returns the page content or None.

```python
async def fetch_page(url) -> Optional[PageContent]
```

--------------------------------

### Manual MCP Registry Publish using mcp-publisher

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/PUBLISHING.md

Instructions for manually publishing to the MCP Registry using the mcp-publisher tool. This involves installing the tool (e.g., via Homebrew on macOS) and then logging in and publishing.

```bash
# Install mcp-publisher
brew install mcp-publisher  # macOS
# or download from https://github.com/modelcontextprotocol/registry/releases

mcp-publisher login github
mcp-publisher publish
```

--------------------------------

### Detect Project Context

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/copilot-instructions.md

This function detects and returns the project's programming language, associated vendors, and confidence levels. It's recommended to run this at the start of a session to understand the project's technical stack.

```Python
mcp_wpilib_detect_project_context()
```

--------------------------------

### Async Search Function Signature

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/CLAUDE.md

Defines the asynchronous function signature for searching documentation. It takes query parameters and returns a list of search results.

```python
async def search(query, version, language, max_results) -> list[SearchResult]
```

--------------------------------

### PageContent Data Class

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/CLAUDE.md

Defines the data structure for the content of a fetched documentation page. It includes metadata like URL, title, vendor, language, version, and fetch timestamp.

```python
@dataclass
class PageContent:
    url, title, content, vendor, language, version, section, last_fetched
```

--------------------------------

### Run Specific Test File

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/CLAUDE.md

Executes a specific test file within the test suite using pytest. This is useful for focusing on a particular area of the codebase during development.

```bash
uv run pytest tests/test_plugins.py -v
uv run pytest tests/test_search.py -v
```

--------------------------------

### SearchResult Data Class

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/CLAUDE.md

Defines the data structure for a search result. It includes fields like URL, title, vendor, language, version, content preview, and relevance score.

```python
@dataclass
class SearchResult:
    url, title, section, vendor, language, version, content_preview, score
```

--------------------------------

### Load and Manage Documentation Plugins (Python)

Source: https://context7.com/ramalamadingdong/agentic-csa/llms.txt

This Python code demonstrates how to use the PluginLoader to discover, load, and manage documentation plugins. It shows loading configuration, initializing the loader, discovering available plugins, loading and initializing enabled plugins, accessing specific plugins, retrieving initialized plugins, and shutting down all plugins.

```Python
from wpilib_mcp.plugin_loader import PluginLoader, load_config

# Load configuration
config = load_config()  # Reads config.json

# Initialize plugin loader
loader = PluginLoader()

# Discover available plugins
available = loader.discover_plugins()
# Returns: ['wpilib', 'rev', 'ctre', 'photonvision', 'redux']

# Load and initialize all enabled plugins
plugins = await loader.load_and_initialize_plugins(config, fail_fast=False)
# Returns: {'wpilib': <Plugin>, 'rev': <Plugin>, ...}

# Access a specific plugin
wpilib_plugin = loader.get_plugin('wpilib')

# Get only initialized plugins
initialized = loader.get_initialized_plugins()

# Shutdown all plugins when done
await loader.shutdown_all()
```

--------------------------------

### Define Vendor Documentation Plugin (Python)

Source: https://context7.com/ramalamadingdong/agentic-csa/llms.txt

This Python code defines a concrete implementation of the PluginBase abstract class. It specifies plugin metadata like name, display name, description, supported versions, languages, and base URLs. It also outlines the methods for initialization, searching documentation, fetching page content, and listing available documentation sections.

```Python
from wpilib_mcp.plugins.base import PluginBase, PluginConfig, SearchResult, PageContent

class MyVendorPlugin(PluginBase):
    @property
    def name(self) -> str:
        return "myvendor"

    @property
    def display_name(self) -> str:
        return "My Vendor"

    @property
    def description(self) -> str:
        return "Documentation for My Vendor products"

    @property
    def supported_versions(self) -> list[str]:
        return ["2025", "2024"]

    @property
    def supported_languages(self) -> list[str]:
        return ["Java", "Python", "C++"]

    @property
    def base_urls(self) -> list[str]:
        return ["https://docs.myvendor.com"]

    async def initialize(self, config: PluginConfig) -> None:
        # Load index files, build BM25 corpus
        self._initialized = True

    async def search(
        self,
        query: str,
        version: str = None,
        language: str = None,
        max_results: int = 10
    ) -> list[SearchResult]:
        # Perform BM25 search and return results
        return results

    async def fetch_page(self, url: str) -> PageContent:
        # Fetch and clean page content
        return PageContent(url=url, title="...", content="...", vendor=self.display_name)

    async def list_sections(self, version: str = None, language: str = None) -> list[DocSection]:
        # Return available documentation sections
        return sections
```

--------------------------------

### Search FRC Documentation (Auto-Detect)

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/copilot-instructions.md

This is the recommended way to search FRC documentation, as it leverages automatic detection of the project's programming language and vendor libraries. This simplifies the search process by removing the need to manually specify these parameters.

```Python
# Let auto-detection handle it (recommended)
mcp_wpilib_search_frc_docs(query="SparkMax configuration")
```

--------------------------------

### MCP Tool: fetch_frc_doc_page

Source: https://context7.com/ramalamadingdong/agentic-csa/llms.txt

Fetches the full content of an FRC documentation page by its URL. It automatically identifies the correct plugin based on the URL.

```APIDOC
## POST /api/mcp/fetch_frc_doc_page

### Description
Fetches the full content of an FRC documentation page by URL. Automatically routes to the correct plugin based on the URL domain. Returns cleaned text content suitable for answering questions about specific documentation pages.

### Method
POST

### Endpoint
/api/mcp/fetch_frc_doc_page

### Parameters
#### Request Body
- **url** (string) - Required - The URL of the FRC documentation page to fetch.

### Request Example
```json
{
  "url": "https://docs.revrobotics.com/brushless/spark-max/closed-loop-control"
}
```

### Response
#### Success Response (200)
- **content** (string) - The full, cleaned text content of the documentation page.
- **source** (string) - The vendor of the documentation.
- **url** (string) - The original URL of the documentation page.
- **language** (string) - The programming language the documentation is for.
- **version** (string) - The FRC year version of the documentation.
- **section** (string) - The section within the vendor's documentation.

#### Response Example
```json
{
  "content": "# Closed Loop Control\n**Source:** REV Robotics\n**URL:** https://docs.revrobotics.com/brushless/spark-max/closed-loop-control\n**Language:** Java\n**Version:** 2025\n**Section:** SparkMax\n---\nThe SPARK MAX can be configured for closed loop control using the built-in PID controller. This allows for velocity and position control modes...",
  "source": "REV Robotics",
  "url": "https://docs.revrobotics.com/brushless/spark-max/closed-loop-control",
  "language": "Java",
  "version": "2025",
  "section": "SparkMax"
}
```
```

--------------------------------

### Search FRC Documentation with Vendor Specificity (Python)

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/copilot-instructions.md

This Python function call illustrates how to search FRC documentation while specifying particular vendors. It's designed to narrow down search results to hardware from specific manufacturers, such as REV for SparkMax controllers. This improves the relevance of the documentation retrieved.

```python
mcp_wpilib_search_frc_docs(query="SparkMax NEO brushless setup", vendors=["rev"])
```

--------------------------------

### HTTP Fetcher with Caching (Python)

Source: https://context7.com/ramalamadingdong/agentic-csa/llms.txt

An asynchronous HTTP client that caches responses for efficient documentation fetching. It allows for configurable cache TTL, size, timeouts, and user agents. You can fetch with or without cache, invalidate specific URLs, clear the entire cache, and use it as a context manager for automatic cleanup.

```python
from wpilib_mcp.utils.fetch import HttpFetcher

# Create fetcher with configuration
fetcher = HttpFetcher(
    cache_ttl_seconds=3600,  # 1 hour cache
    max_cache_size=1000,
    timeout=30.0,
    user_agent="WPILib-MCP-Server/0.1.0"
)

# Fetch with caching (default)
html = await fetcher.fetch("https://docs.wpilib.org/en/stable/docs/software/commandbased/index.html")

# Fetch without cache
fresh_html = await fetcher.fetch(url, use_cache=False)

# Invalidate specific URL
fetcher.invalidate("https://docs.wpilib.org/some-page.html")

# Clear entire cache
fetcher.clear_cache()

# Use as context manager for automatic cleanup
async with HttpFetcher() as fetcher:
    content = await fetcher.fetch("https://docs.revrobotics.com/...")

# Manual cleanup
await fetcher.close()
```

--------------------------------

### Detect FRC Project Context (Python)

Source: https://context7.com/ramalamadingdong/agentic-csa/llms.txt

This Python code demonstrates how to automatically detect the FRC project's programming language and vendor libraries. It shows using `get_project_context` for quick detection in the current directory or from a specific path, and using `ProjectContextDetector` for more control and caching. It also illustrates how to retrieve search filters based on the detected context.

```Python
from wpilib_mcp.utils.context import get_project_context, ProjectContextDetector
from pathlib import Path

# Quick context detection (uses current directory)
context = get_project_context()
print(f"Language: {context.language}")      # "Java"
print(f"Vendors: {context.vendors}")        # ["rev", "ctre"]
print(f"Confidence: {context.confidence}")  # 0.85
print(f"Sources: {context.detection_sources}")
# ['build.gradle found', '42 .java files', 'vendordep: REVLib.json (rev)']

# Detect from specific path
project_path = Path("/home/user/robot-project")
context = get_project_context(project_path)

# Full detector with caching
detector = ProjectContextDetector(project_root=Path.cwd())
context = detector.detect()

# Get search filters directly
filters = detector.get_search_filters()
# Returns: {"language": "Java", "vendors": ["wpilib", "rev", "ctre"]}
```

--------------------------------

### Configure FIRST Agentic CSA in VS Code

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/README.md

Configuration snippet for VS Code's MCP (Multi-language Code Provider) extension to integrate the FIRST Agentic CSA. This allows VS Code to use the tool for searching FRC documentation.

```json
{
    "frc-docs": {
      "command": "uvx",
      "args": ["first-agentic-csa"]
    }
}
```

--------------------------------

### Configuration File Structure (JSON)

Source: https://context7.com/ramalamadingdong/agentic-csa/llms.txt

The main configuration file (`config.json`) controls plugin settings, caching parameters, and default search options. It allows enabling/disabling specific vendor plugins, specifying supported versions and languages for each, and setting global cache and search defaults.

```json
{
  "plugins": {
    "wpilib": {
      "enabled": true,
      "versions": ["2025"],
      "languages": ["Java", "Python", "C++"]
    },
    "rev": {
      "enabled": true,
      "languages": ["Java", "C++", "Python"]
    },
    "ctre": {
      "enabled": true,
      "languages": ["Java", "C++", "Python"]
    },
    "redux": {
      "enabled": false,
      "languages": ["Java"]
    },
    "photonvision": {
      "enabled": true,
      "languages": ["Java", "C++", "Python"]
    }
  },
  "cache": {
    "ttl_seconds": 3600,
    "max_size_mb": 200
  },
  "search": {
    "default_max_results": 10,
    "default_language": "Java",
    "default_version": "2025"
  }
}
```

--------------------------------

### Fetch FRC Documentation Page Content (MCP Tool)

Source: https://context7.com/ramalamadingdong/agentic-csa/llms.txt

Fetches the complete content of a specific FRC documentation page using its URL. The tool automatically directs the request to the appropriate plugin based on the URL's domain. It returns cleaned text content, suitable for direct use in answering questions about the documentation.

```json
{
  "url": "https://docs.revrobotics.com/brushless/spark-max/closed-loop-control"
}
```

--------------------------------

### VS Code MCP Server Configuration (JSON)

Source: https://context7.com/ramalamadingdong/agentic-csa/llms.txt

This JSON configuration is used within VS Code to set up the MCP server for integration with AI assistants. It specifies the command to run the server and any necessary arguments.

```json
{
  "frc-docs": {
    "command": "uvx",
    "args": ["first-agentic-csa"]
  }
}
```

--------------------------------

### MCP Tool: search_frc_docs

Source: https://context7.com/ramalamadingdong/agentic-csa/llms.txt

Searches FRC documentation across WPILib and vendor libraries using BM25 ranking. It can auto-detect project language and vendors.

```APIDOC
## POST /api/mcp/search_frc_docs

### Description
Searches FRC documentation across WPILib and vendor libraries with BM25 ranking. Returns ranked results with titles, URLs, and content previews. Supports auto-detection of project language and vendors from the current working directory.

### Method
POST

### Endpoint
/api/mcp/search_frc_docs

### Parameters
#### Request Body
- **query** (string) - Required - The natural language query to search for.
- **vendors** (array of strings) - Optional - A list of specific vendors to search within (e.g., ["wpilib", "rev"]). Defaults to ["all"].
- **version** (string) - Optional - The FRC year version to search (e.g., "2025").
- **language** (string) - Optional - The programming language to filter results by (e.g., "Java", "Python").
- **max_results** (integer) - Optional - The maximum number of results to return. Defaults to 10.
- **auto_detect** (boolean) - Optional - If true, attempts to auto-detect project language and vendors from the current working directory. Defaults to true.

### Request Example
```json
{
  "query": "SparkMax PID configuration",
  "vendors": ["all"],
  "version": "2025",
  "language": "Java",
  "max_results": 10,
  "auto_detect": true
}
```

### Response
#### Success Response (200)
- **results** (array of objects) - A list of ranked search results.
  - **title** (string) - The title of the documentation page.
  - **vendor** (string) - The vendor of the documentation.
  - **section** (string) - The section within the vendor's documentation.
  - **language** (string) - The programming language the documentation is for.
  - **url** (string) - The URL of the documentation page.
  - **content_preview** (string) - A short preview of the relevant content.

#### Response Example
```json
{
  "results": [
    {
      "title": "Closed Loop Control",
      "vendor": "REV Robotics",
      "section": "SparkMax",
      "language": "Java",
      "url": "https://docs.revrobotics.com/brushless/spark-max/closed-loop-control",
      "content_preview": "Configure PID constants using the SparkMaxPIDController class..."
    }
  ]
}
```
```

--------------------------------

### MCP Tool: detect_project_context

Source: https://context7.com/ramalamadingdong/agentic-csa/llms.txt

Detects the FRC project's programming language and vendor libraries by scanning project files. Useful for understanding project dependencies.

```APIDOC
## POST /api/mcp/detect_project_context

### Description
Detects the FRC project's programming language and vendor libraries by scanning source files, build configs, and vendordeps. Useful for understanding what hardware and libraries the current project uses.

### Method
POST

### Endpoint
/api/mcp/detect_project_context

### Parameters
#### Request Body
- **project_path** (string) - Required - The absolute or relative path to the FRC project directory.

### Request Example
```json
{
  "project_path": "/home/user/frc-robot-2025"
}
```

### Response
#### Success Response (200)
- **language** (string) - The detected programming language (e.g., "Java", "Python", "C++").
- **vendors** (array of strings) - A list of detected vendor libraries (e.g., ["rev", "ctre"]).
- **confidence** (float) - A score indicating the confidence level of the detection (0.0 to 1.0).
- **detection_sources** (array of strings) - A list of files or indicators that contributed to the detection.

#### Response Example
```json
{
  "language": "Java",
  "vendors": ["rev", "ctre", "photonvision"],
  "confidence": 0.95,
  "detection_sources": [
    "build.gradle found",
    "42 .java files",
    "vendordep: REVLib.json (rev)",
    "vendordep: Phoenix6.json (ctre)",
    "vendordep: photonlib.json (photonvision)",
    "import in Robot.java (rev)",
    "import in Drivetrain.java (ctre)"
  ]
}
```
```

--------------------------------

### Search FRC Documentation (Manual Context)

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/copilot-instructions.md

This function allows for manual specification of the programming language and vendors when searching FRC documentation. This is useful when auto-detection needs to be overridden or when working in environments where auto-detection might be unreliable.

```Python
# Or disable auto-detection if needed
mcp_wpilib_search_frc_docs(query="SparkMax configuration", auto_detect=false, vendors=["rev"], language="Java")
```

--------------------------------

### Search FRC Documentation (MCP Tool)

Source: https://context7.com/ramalamadingdong/agentic-csa/llms.txt

Searches FRC documentation across WPILib and vendor libraries using BM25 ranking. It returns ranked results with titles, URLs, and content previews. This tool supports auto-detection of the project's programming language and vendors based on the current working directory.

```json
{
  "query": "SparkMax PID configuration",
  "vendors": ["all"],
  "version": "2025",
  "language": "Java",
  "max_results": 10,
  "auto_detect": true
}
```

--------------------------------

### Search FRC Documentation (Vendor-Specific)

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/copilot-instructions.md

This function searches the FRC documentation for queries specific to a particular vendor. It allows specifying the vendor (e.g., 'rev' for REV Robotics, 'ctre' for CTRE) and can limit the number of results.

```Python
mcp_wpilib_search_frc_docs(query="SparkMax current limits", vendors=["rev"])
```

```Python
mcp_wpilib_search_frc_docs(query="TalonFX motion magic", vendors=["ctre"])
```

```Python
mcp_wpilib_search_frc_docs(query="brushless motor setup", vendors=["rev"], max_results=5)
```

```Python
mcp_wpilib_search_frc_docs(query="brushless motor setup", vendors=["ctre"], max_results=5)
```

--------------------------------

### Fetch FRC Documentation Page

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/copilot-instructions.md

This function fetches the full content of a specific FRC documentation page given its URL. This is typically used after identifying a high-confidence search result.

```Python
mcp_wpilib_fetch_frc_doc_page(url="https://docs.revrobotics.com/...")
```

--------------------------------

### Search FRC Documentation (General)

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/copilot-instructions.md

This function searches the FRC documentation for general queries. It utilizes the MCP server and automatically detects the project's programming language and vendor libraries.

```Python
mcp_wpilib_search_frc_docs(query="how to configure PID", vendors=["all"])
```

--------------------------------

### BM25 Search Index for FRC Documentation (Python)

Source: https://context7.com/ramalamadingdong/agentic-csa/llms.txt

This Python code showcases the BM25SearchIndex utility for creating and querying a search index optimized for FRC documentation. It covers index creation with options for stop word removal and fuzzy matching, building the index from a list of items using a text extractor, performing basic and enhanced searches (with query expansion and suggestions), and searching with a filter function.

```Python
from wpilib_mcp.utils.search import BM25SearchIndex, ScoredResult

# Create and build index
index = BM25SearchIndex(remove_stop_words=True, enable_fuzzy=True)

# Build from items with text extractor
pages = [
    {"title": "SparkMax Setup", "content": "Configure CANSparkMax..."},
    {"title": "PID Tuning", "content": "Tune PID constants for velocity..."},
]
index.build(
    items=pages,
    text_extractor=lambda p: f"{p['title']} {p['content']}"
)

# Basic search
results = index.search("sparkmax pid", max_results=5)
for result in results:
    print(f"Score: {result.score:.2f}, Item: {result.item['title']}")

# Enhanced search with metadata
response = index.search_enhanced(
    query="motor controller setup",
    max_results=10,
    expand_query=True,      # Expands "motor controller" to include "sparkmax", "talonfx"
    include_suggestions=True
)
print(f"Query tokens: {response.query_tokens}")
print(f"Expanded terms: {response.expanded_terms}")  # ['sparkmax', 'spark max', 'talonfx', ...]
print(f"Suggestions: {response.suggestions}")  # ['sparkmax' → 'sparkflex'] if typo detected

# Search with filter function
java_results = index.search_with_filter(
    query="velocity control",
    filter_fn=lambda page: page.get("language") == "Java",
    max_results=5
)
```

--------------------------------

### PageContent Data Class (Python)

Source: https://context7.com/ramalamadingdong/agentic-csa/llms.txt

Represents the full content of a fetched documentation page. It stores the URL, title, the actual content (as a string, potentially with Markdown), vendor, language, version, section, and the timestamp of when the page was last fetched.

```python
from wpilib_mcp.plugins.base import PageContent

page = PageContent(
    url="https://docs.wpilib.org/en/stable/docs/software/commandbased/index.html",
    title="Command-Based Programming",
    content="# Command-Based Programming\n\nThe command-based paradigm...",
    vendor="WPILib",
    language="Java",
    version="2025",
    section="Software",
    last_fetched="2025-01-15T10:30:00"
)
```

--------------------------------

### Fetch Full FRC Documentation Page Content (Python)

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/copilot-instructions.md

This Python function is used to retrieve the complete content of an FRC documentation page, given its URL. It's a crucial step after identifying a relevant documentation link, allowing for detailed analysis and code generation based on the fetched information.

```python
mcp_wpilib_fetch_frc_doc_page(url="...")
```

--------------------------------

### List Available FRC Documentation Sections (MCP Tool)

Source: https://context7.com/ramalamadingdong/agentic-csa/llms.txt

Lists the available documentation sections and categories for specified FRC vendors and versions. This is useful for browsing the documentation structure and understanding the scope of available information from each vendor.

```json
{
  "vendors": ["wpilib", "rev"],
  "version": "2025",
  "language": "Java"
}
```

--------------------------------

### Detect FRC Project Context (MCP Tool)

Source: https://context7.com/ramalamadingdong/agentic-csa/llms.txt

Detects the programming language and vendor libraries used in an FRC project by analyzing source files, build configurations, and vendordeps. This information is crucial for understanding the project's dependencies and filtering documentation search results effectively.

```json
{
  "project_path": "/home/user/frc-robot-2025"
}
```

--------------------------------

### SearchResult Data Class (Python)

Source: https://context7.com/ramalamadingdong/agentic-csa/llms.txt

Represents a single search result from a documentation query. It includes fields for the URL, title, section, vendor, language, version, a content preview, and a relevance score. This class can be converted to a dictionary for serialization.

```python
from wpilib_mcp.plugins.base import SearchResult

result = SearchResult(
    url="https://docs.revrobotics.com/brushless/spark-max/closed-loop-control",
    title="Closed Loop Control",
    section="SparkMax",
    vendor="REV Robotics",
    language="Java",
    version="2025",
    content_preview="Configure PID constants using the SparkMaxPIDController...",
    score=0.85
)

# Convert to dict for serialization
data = result.to_dict()
```

--------------------------------

### Override Auto-Detection for FRC Documentation Search (Python)

Source: https://github.com/ramalamadingdong/agentic-csa/blob/master/copilot-instructions.md

This function demonstrates how to manually specify search parameters for FRC documentation. It allows overriding auto-detection for language and version, ensuring targeted searches. This is useful when the default detection is incorrect or when a specific version is required.

```python
search_frc_docs(query="command based", language="Python", version="2025", auto_detect=false)
```

--------------------------------

### MCP Tool: list_frc_doc_sections

Source: https://context7.com/ramalamadingdong/agentic-csa/llms.txt

Lists available FRC documentation sections and categories from specified vendors. Useful for browsing documentation structure.

```APIDOC
## POST /api/mcp/list_frc_doc_sections

### Description
Lists available FRC documentation sections and categories from each vendor. Useful for browsing what documentation is available and understanding the structure of each vendor's docs.

### Method
POST

### Endpoint
/api/mcp/list_frc_doc_sections

### Parameters
#### Request Body
- **vendors** (array of strings) - Optional - A list of specific vendors to list sections for (e.g., ["wpilib", "rev"]). If omitted, lists for all available vendors.
- **version** (string) - Optional - The FRC year version to list sections for (e.g., "2025").
- **language** (string) - Optional - The programming language to filter sections by (e.g., "Java", "Python").

### Request Example
```json
{
  "vendors": ["wpilib", "rev"],
  "version": "2025",
  "language": "Java"
}
```

### Response
#### Success Response (200)
- **sections** (object) - An object where keys are vendor names and values are lists of their documentation sections.
  - **vendor_name** (object) - Contains details about sections for a specific vendor.
    - **section_name** (string) - The name of the documentation section.
    - **page_count** (integer) - The number of pages within that section.

#### Response Example
```json
{
  "sections": {
    "WPILIB": [
      {"section_name": "Getting Started", "page_count": 45},
      {"section_name": "Software", "page_count": 120},
      {"section_name": "Hardware", "page_count": 35}
    ],
    "REV": [
      {"section_name": "SparkMax", "page_count": 28},
      {"section_name": "SparkFlex", "page_count": 15}
    ]
  }
}
```
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.