docs: update MkDocs site for enterprise repositioning

- mkdocs.yml: updated site_description, added MCP and JDK API nav entries
- index.md: enterprise tagline, MCP metrics, agent integration nav section
- about.md: MCP as #1 differentiator, agent-native comparison table,
  agentic AI memory use case, removed competitor name-drops
- architecture/overview.md: added spector-mcp to module diagram,
  dependency graph, and new MCP agent data flow sequence diagram
- roadmap.md: new Agentic AI section (MCP server, Streamable HTTP,
  LoRA adapter routing, ColBERT late interaction), updated summary table

Author: sbharatjoshi

docs/docs/about.md

@@ -1,17 +1,25 @@
 # 🌟 What is Spector Search?
 
-> **The fastest pure-Java semantic search engine — combining vector similarity, keyword search, and hybrid ranking in a single embeddable library with zero external dependencies.**
+> **The Zero-Overhead, Agent-Ready AI Memory Backbone.**
+>
+> Legacy search engines bolted vectors onto text databases. Spector is designed from the ground up for modern AI — combining vector similarity, keyword search, and hybrid ranking in a single embeddable library with zero external dependencies. Connect any AI agent via the built-in MCP server, or embed directly in your application.
 
-Spector Search is an open-source, high-performance search engine built entirely on modern Java 25. It's designed for developers who want sub-millisecond search without the complexity of managing external infrastructure. Drop in a JAR, write a few lines of code, and you have production-grade hybrid search.
+Spector Search is an open-source, high-performance search engine built entirely on modern Java 25. It's designed for developers who want sub-millisecond search, native AI agent integration, and zero infrastructure complexity. Drop in a JAR, write a few lines of code, and you have production-grade hybrid search with built-in agent support.
 
 ---
 
 ## 🎯 What It Does
 
-Spector Search indexes documents with their vector embeddings and text content, then retrieves them using multiple strategies:
+Spector Search indexes documents with their vector embeddings and text content, then retrieves them using multiple strategies — directly from AI agents or your application code:
 
 ```mermaid
 graph LR
+    subgraph Clients
+        MCP["🤖 AI Agent (MCP)"]
+        REST["🌐 REST API"]
+        SDK["📦 Java SDK"]
+    end
+    
     subgraph Search Modes
         A[Vector Search] --> D[Results]
         B[Keyword Search] --> D
@@ -25,6 +33,10 @@ graph LR
         C --> F
         C --> G[RRF Fusion]
     end
+    
+    MCP --> A & B & C
+    REST --> A & B & C
+    SDK --> A & B & C
 ```
 
 | Mode | How It Works | Best For |
@@ -39,6 +51,20 @@ graph LR
 
 ## 💎 Key Differentiators
 
+### 🤖 Agent-Native (MCP Protocol)
+
+Includes a built-in [Model Context Protocol](https://modelcontextprotocol.io/) server with 6 tools. AI agents connect directly via JSON-RPC — no Python frameworks, no network round-trips.
+
+| Feature | Python Vector DB MCP | **Spector MCP** |
+|:---|:---|:---|
+| Search latency | 2–10ms | **50–200µs** (100× faster) |
+| Network overhead | HTTP/gRPC round-trip | **Zero** (in-process) |
+| Concurrent queries | Limited by Python GIL | **10,000+ QPS** |
+| Dependencies | Python framework stack | **Single JAR** |
+
+> [!TIP]
+> See the [MCP Server Guide](../sdk-usage/mcp-server.md) to connect Claude Desktop, Cursor, or any MCP client in minutes.
+
 ### 📦 Pure Java, Zero Dependencies
 
 Unlike most vector databases that rely on C++, Rust, or Python bindings, Spector Search is 100% Java. It uses the JDK's own Vector API for SIMD acceleration — no JNI, no native libraries, no external infrastructure.
@@ -49,7 +75,7 @@ Unlike most vector databases that rely on C++, Rust, or Python bindings, Spector
 ### 🚀 Modern JVM Technologies
 
 | Technology | Purpose |
-|-----------|---------|
+|-----------|---------| 
 | Java Vector API | SIMD-accelerated math (AVX2/AVX-512/NEON) |
 | Panama FFM | Zero-copy memory-mapped storage, GPU interop |
 | Virtual Threads | Millions of concurrent operations without thread pools |
@@ -100,7 +126,7 @@ Spector offers two quantization paths:
 ### Latency Comparison (100K docs, 128-dim, top-10)
 
 | Engine | Language | Vector Avg | Vector P99 |
-|--------|----------|-----------|-----------|
+|--------|----------|-----------|-----------| 
 | **⚡ Spector Search** | **Java 25** | **0.13 ms** | **0.26 ms** |
 | hnswlib | C++ | 0.1–0.5 ms | ~1 ms |
 | FAISS | C++ | 0.2–0.8 ms | 1–2 ms |
@@ -115,8 +141,9 @@ Spector offers two quantization paths:
 ### Feature Comparison
 
 | Feature | Spector | Elasticsearch | Qdrant | Milvus | hnswlib |
-|---------|---------|--------------|--------|--------|---------|
+|---------|---------|--------------|--------|--------|---------| 
 | **Deployment** | Embedded + Server | Cluster only | Server only | Cluster only | Embedded only |
+| **MCP Server** | ✅ Built-in (6 tools) | ❌ | ❌ | ❌ | ❌ |
 | **Hybrid Search** | ✅ RRF built-in | ✅ RRF | ✅ Sparse+Dense | ✅ RRF | ❌ |
 | **Zero Dependencies** | ✅ JDK only | ❌ Heavy stack | ❌ Tokio runtime | ❌ etcd, MinIO, Pulsar | ✅ Header-only |
 | **Virtual Threads** | ✅ Project Loom | ❌ Platform threads | N/A (Rust async) | N/A (Go goroutines) | N/A |
@@ -133,9 +160,13 @@ Spector offers two quantization paths:
 
 ## 🛠️ Use Cases
 
+### 🤖 Agentic AI Memory
+
+Connect AI agents (Claude, Cursor, custom) directly to Spector via the built-in MCP server. The agent autonomously ingests documents, searches for relevant context, and retrieves information — all with zero Python glue-code. *"Point your LLM at Spector's MCP port, and it instantly has mathematically-perfect long-term memory."*
+
 ### 🤖 Retrieval-Augmented Generation (RAG)
 
-Ingest documents (PDF, HTML, Markdown), chunk them with token awareness, generate embeddings, and retrieve relevant context for LLM prompting — all through a single `/api/v1/rag` endpoint.
+Ingest documents (PDF, HTML, Markdown), chunk them with token awareness, generate embeddings, and retrieve relevant context for LLM prompting — all through a single `/api/v1/rag` endpoint or the `rag_query` MCP tool.
 
 ### 🔍 Semantic Search Applications
 
@@ -159,6 +190,7 @@ Drop Spector Search into existing Java applications without infrastructure chang
 
 > [!NOTE]
 > **Choose Spector Search when:**
+> - You want AI agents to autonomously search your data (MCP integration)
 > - You want sub-millisecond hybrid search without infrastructure complexity
 > - Your stack is Java/JVM and you want native integration
 > - You need an embedded search library with server-mode option
@@ -169,14 +201,16 @@ Drop Spector Search into existing Java applications without infrastructure chang
 > **Consider alternatives when:**
 > - You need a managed cloud service with zero ops
 > - Your team primarily works in Python/Rust/Go
-> - You need built-in ML model serving (Weaviate, Milvus)
+> - You need built-in ML model serving
 
 ---
 
 ## 🚀 Next Steps
 
 - [Getting Started](getting-started/quickstart.md) — Build and run your first search in 5 minutes
 
+- [MCP Server Guide](sdk-usage/mcp-server.md) — Connect an AI agent in 3 steps
+
 - [Architecture Overview](architecture/overview.md) — Understand how it works under the hood
 
 - [REST API Reference](api-reference/rest-endpoints.md) — Full API documentation

docs/docs/architecture/overview.md

@@ -1,6 +1,6 @@
 # 🏗️ Architecture Overview
 
-> **Spector Search is a modular, JVM-native vector search engine organized as a Maven multi-module project.** This page covers the module structure, dependency graph, data flow, threading model, and memory architecture that make sub-millisecond search possible.
+> **Spector Search is a modular, JVM-native AI memory backbone organized as a Maven multi-module project.** This page covers the module structure, dependency graph, data flow, threading model, and memory architecture that make sub-millisecond, agent-native search possible.
 
 ---
 
@@ -39,6 +39,7 @@ graph LR
     subgraph "⚡ Engine & Interfaces"
         engine["spector-engine<br/><i>Unified facade + lifecycle</i>"]
         server["spector-server<br/><i>REST API + SSE streaming</i>"]
+        mcp["spector-mcp<br/><i>MCP Server — Agent-native</i>"]
         cluster["spector-cluster<br/><i>Distributed gRPC search</i>"]
         cli["spector-cli<br/><i>spectorctl CLI</i>"]
         client["spector-client<br/><i>Java client SDK</i>"]
@@ -61,6 +62,7 @@ graph LR
 graph TD
     server["🖥️ server"] --> cluster["🌐 cluster"]
     server --> engine["⚡ engine"]
+    mcp["🤖 mcp"] --> engine
 
     cluster --> engine
     engine --> query["🔍 query"]
@@ -94,6 +96,7 @@ graph TD
 |------|-------------|
 | `cluster → engine → query → index → storage → core` | Main data path |
 | `server → engine` | REST API entry point |
+| `mcp → engine` | MCP agent entry point (in-process, zero network) |
 | `engine → ingestion` | Document ingestion pipeline |
 | `engine → rag` | RAG context assembly pipeline |
 | `engine → gpu` | Optional GPU acceleration |
@@ -178,6 +181,33 @@ sequenceDiagram
 
 ---
 
+## 🤖 Data Flow: MCP Agent Path
+
+```mermaid
+sequenceDiagram
+    participant Agent as 🤖 AI Agent (Claude/Cursor)
+    participant MCP as 📡 MCP Transport (stdio)
+    participant Handler as 🔧 McpToolHandler
+    participant Engine as ⚡ SpectorEngine
+    participant SIMD as 🔬 SIMD Kernels
+
+    Agent->>MCP: tools/call {"name": "semantic_search", "arguments": {"query": "..."}}
+    MCP->>Handler: SemanticSearchTool.execute(engine, args)
+    Handler->>Engine: engine.search(query, topK)
+    Engine->>SIMD: HNSW traversal (off-heap MemorySegment)
+    SIMD-->>Engine: ScoredResult[] (~100µs)
+    Engine-->>Handler: SearchResponse
+    Handler-->>MCP: CallToolResult
+    MCP-->>Agent: JSON-RPC response with search results
+```
+
+The MCP path is identical to the programmatic API path — the MCP server simply wraps `SpectorEngine` method calls with JSON-RPC transport. There is **zero network overhead** because everything runs in the same JVM process.
+
+> [!TIP]
+> For full MCP architecture details, tool schemas, and design patterns, see the dedicated [MCP Integration](mcp-integration.md) page.
+
+---
+
 ## 🧵 Threading Model: Virtual Threads
 
 Spector Search is designed from the ground up for Java virtual threads:

docs/docs/index.md

@@ -1,22 +1,23 @@
 # ⚡ Welcome to Spector Search
 
-> **Ultra-fast, SIMD-accelerated semantic search engine built on Java Vector API + modern JVM technologies.**
+> **The Zero-Overhead, Agent-Ready AI Memory Backbone.**
 
-Welcome to the Spector Search wiki — your central hub for everything about Spector Search, a high-performance pure-Java vector search engine. Whether you're building RAG pipelines, powering recommendation systems, or need sub-millisecond search with zero infrastructure, you're in the right place.
+Welcome to the Spector Search documentation — your central hub for the high-performance, agent-native AI search engine. Whether you're connecting AI agents via MCP, building RAG pipelines, powering recommendation systems, or need sub-millisecond search with zero infrastructure, you're in the right place.
 
 ---
 
 ## 🔥 Why Spector Search?
 
 | Metric | Value |
 |--------|-------|
+| 🤖 MCP Tools | **6 agent-ready tools** (semantic, hybrid, RAG, ingest, delete, status) |
 | ⚡ Vector Search Latency | **0.05 ms** avg @ 10K docs (128-dim) |
 | 🔍 Keyword Search Latency | **0.98 ms** avg @ 100K docs |
 | 🧬 Hybrid Search Latency | **0.17 ms** avg @ 10K docs |
 | 🚀 Vector Throughput | **18,800 queries/sec** @ 10K |
 | 🧵 Concurrent Hybrid | **14,000+ ops/sec** @ 16 threads (384-dim) |
 | 🗜️ IVF-PQ + TurboQuant | **8–32× memory reduction** |
-| ✅ Test Suite | **316+ tests**, all passing |
+| ✅ Test Suite | **331+ tests**, all passing |
 | 📦 Dependencies | **Zero** (JDK only) |
 
 ---
@@ -29,8 +30,16 @@ Welcome to the Spector Search wiki — your central hub for everything about Spe
 |------|-------------|
 | [Getting Started](getting-started/quickstart.md) | Build, run, and search in 5 minutes |
 | [What is Spector Search](about.md) | Product overview, use cases, and comparisons |
+| [JDK API Status](getting-started/jdk-api-status.md) | Vector API, Panama FFM, and preview feature compatibility |
 | [FAQ](faq.md) | Common questions answered |
 
+### 🤖 Agent Integration (MCP)
+
+| Page | Description |
+|------|-------------|
+| [MCP Integration Architecture](architecture/mcp-integration.md) | How the MCP server works under the hood |
+| [MCP Server Guide](sdk-usage/mcp-server.md) | Setup for Claude Desktop, Cursor, and custom agents |
+
 ### 🏗️ Architecture & Concepts
 
 | Page | Description |
@@ -65,17 +74,20 @@ Welcome to the Spector Search wiki — your central hub for everything about Spe
 
 ```mermaid
 graph LR
-    A[📄 Document] --> B[🧩 Chunking]
-    B --> C[🧠 Embedding]
-    C --> D[⚡ HNSW + BM25 Index]
-    D --> E[🔍 Hybrid Search]
-    E --> F[🎯 RRF Fusion]
-    F --> G[🤖 LLM Re-ranking]
-    G --> H[✨ Results]
+    A["🤖 AI Agent"] --> B["📡 MCP Server"]
+    B --> C["⚡ SpectorEngine"]
+    C --> D["🧠 Hybrid Search"]
+    D --> E["🎯 RRF Fusion"]
+    E --> F["🤖 LLM Re-ranking"]
+    F --> G["✨ Results"]
+    
+    H["📄 Document"] --> I["🧩 Chunking"]
+    I --> J["🧬 Embedding"]
+    J --> C
 ```
 
 > [!TIP]
-> New here? Start with [Getting Started](getting-started/quickstart.md) to build and run your first search in under 5 minutes.
+> New here? Start with [Getting Started](getting-started/quickstart.md) to build and run your first search in under 5 minutes. Want to connect an AI agent? See the [MCP Server Guide](sdk-usage/mcp-server.md).
 
 ---
 
@@ -85,10 +97,11 @@ graph LR
 |---|---|
 | **Language** | Java 25 |
 | **License** | Apache 2.0 |
-| **Modules** | 16 Maven modules |
+| **Modules** | 18 Maven modules |
 | **Dependencies** | Zero (JDK only) |
 | **SIMD** | AVX2 / AVX-512 / NEON |
 | **GPU** | CUDA via Panama FFM |
+| **MCP** | Built-in, 6 agent-ready tools |
 | **Distributed** | gRPC fan-out + consistent hashing |
 
 ---

docs/docs/roadmap.md

@@ -93,7 +93,7 @@ The 4-byte `float32 exactNormSq` header can be compressed to 2 bytes using `floa
 !!! note "Status: Future Research"
     Very high implementation effort. Most aggressive compression option.
 
-After FWHT rotation, instead of scalar INT8/INT4 quantization, apply **Product Quantization** to the rotated coordinates. The FWHT rotation makes coordinates near-independent (isotropized), which is the ideal input distribution for PQ — similar to how FAISS's OPQ (Optimized PQ) works, but using FWHT instead of a learned rotation.
+After FWHT rotation, instead of scalar INT8/INT4 quantization, apply **Product Quantization** to the rotated coordinates. The FWHT rotation makes coordinates near-independent (isotropized), which is the ideal input distribution for PQ — similar to how Optimized PQ (OPQ) works with learned rotations, but using FWHT instead of an expensive SVD-based rotation matrix.
 
 **Memory layout:**
 ```
@@ -173,6 +173,65 @@ Instead of uniform INT8 across all dimensions, assign more bits to high-variance
 
 ---
 
+## Agentic AI
+
+### ✅ Native MCP Server {#mcp-server}
+
+!!! success "Completed"
+    Implemented in `spector-mcp` module. 6 tools, stdio transport, agent-native search.
+
+Built-in [Model Context Protocol](https://modelcontextprotocol.io/) server that gives AI agents (Claude Desktop, Cursor, autonomous agents) direct, in-process access to Spector’s search engine. Zero network overhead — tool handlers call `SpectorEngine` directly via virtual threads.
+
+**Tools:** `semantic_search`, `hybrid_search`, `rag_query`, `ingest_document`, `delete_document`, `engine_status`
+
+**Architecture:**
+- `McpToolHandler` abstract base (template method: timing, error handling, arg parsing)
+- `ToolSchemaBuilder` fluent JSON schema construction
+- `SpectorToolRegistry` for Open/Closed Principle tool registration
+- `SpectorResourceProvider` + `SpectorPromptProvider` for MCP resources/prompts
+- `ResultFormatter` shared formatting utilities
+
+---
+
+### 🔜 Streamable HTTP Transport {#mcp-http}
+
+!!! info "Status: Planned (next)"
+    Stdio covers Claude Desktop, Cursor, and all local agents. HTTP needed for cloud/remote deployments.
+
+Add HTTP-based MCP transport for scenarios where the agent and Spector run on different machines. The official MCP SDK supports Streamable HTTP transport — Spector would expose the same 6 tools over an HTTP endpoint.
+
+**Use cases:** Cloud deployments, remote agent connections, multi-agent architectures.
+
+---
+
+### 🔬 LoRA Adapter Routing {#lora-routing}
+
+!!! note "Status: Future Research"
+    Requires LoRA weight format specification and SIMD matrix multiply implementation.
+
+Multi-tenant query projection via SIMD matrix multiply. Instead of creating separate indexes per tenant, store one base index and apply per-tenant LoRA weight matrices at query time using Panama FMA loops.
+
+**How it works:**
+- Ingest base model embeddings once
+- Each tenant uploads a small LoRA matrix ($W_A$, typically 768×32 or similar)
+- At query time: $q_{tenant} = q_{base} \times W_A$ (microseconds via Panama SIMD)
+- Search the same index with the projected query
+
+**Expected impact:** Zero-downtime multi-tenant customization without index duplication.
+
+---
+
+### 🔬 ColBERT Late Interaction Reranking {#colbert}
+
+!!! note "Status: Future Research"
+    Requires token-level vector storage and MaxSim SIMD kernel.
+
+Native ColBERT reranking using Panama FMA loops. ColBERT stores a vector for every token in a document, then computes relevance via MaxSim (maximum similarity per query token). Python struggles with this due to GIL contention when routing massive matrices between C++ and Python memory.
+
+**Spector advantage:** Off-heap `MemorySegment` arrays and Fused-Multiply-Add Panama loops can natively execute ColBERT MaxSim reranking faster than almost any competitor.
+
+---
+
 ## Compute & Hardware
 
 ### 🔜 GPU Kernel Dispatch {#gpu-dispatch}
@@ -240,12 +299,16 @@ Migrated all 6 concurrency sites from unstructured `ExecutorService` + `Future`
 | # | Improvement | Compression | Recall Impact | Effort | Status |
 |---|------------|-------------|---------------|--------|--------|
 | 1 | **VASQ-4** | 6–8× vs float32 | -2 to -4% (mitigated w/ rescore) | Medium | ✅ Done |
-| 2 | **Padding-aware storage** | +25% (non-pow2 dims) | None (L2) | Low | 🔜 Next |
-| 3 | **Norm header f16** | +2 bytes/vec | Negligible | Very Low | 🔜 Next |
-| 4 | **VASQ-PQ hybrid** | 16–32× vs float32 | -7 to -15% | Very High | 🔬 Research |
-| 5 | **Flat-mode VASQ** | 3× on flat shards | None or -0.5% | Medium | 🔬 Research |
-| 6 | **Adaptive bit-width** | ~10–15% | Negligible | Very High | 🔴 Not planned |
-| 7 | **GPU kernel dispatch** | N/A (compute) | N/A | Medium | 🔜 Infra ready |
-| 8 | **NPU acceleration** | N/A (compute) | N/A | High | 🔬 Exploratory |
-| 9 | **WASM edge runtime** | N/A (deployment) | N/A | High | 🔬 Exploratory |
-| 10 | **Structured concurrency** | N/A (runtime) | N/A | Low | ✅ Done |
+| 2 | **Native MCP Server** | N/A (agent integration) | N/A | Medium | ✅ Done |
+| 3 | **Padding-aware storage** | +25% (non-pow2 dims) | None (L2) | Low | 🔜 Next |
+| 4 | **Norm header f16** | +2 bytes/vec | Negligible | Very Low | 🔜 Next |
+| 5 | **Streamable HTTP transport** | N/A (deployment) | N/A | Medium | 🔜 Planned |
+| 6 | **VASQ-PQ hybrid** | 16–32× vs float32 | -7 to -15% | Very High | 🔬 Research |
+| 7 | **Flat-mode VASQ** | 3× on flat shards | None or -0.5% | Medium | 🔬 Research |
+| 8 | **LoRA adapter routing** | N/A (multi-tenant) | N/A | High | 🔬 Research |
+| 9 | **ColBERT late interaction** | N/A (reranking) | N/A | High | 🔬 Research |
+| 10 | **Adaptive bit-width** | ~10–15% | Negligible | Very High | 🔴 Not planned |
+| 11 | **GPU kernel dispatch** | N/A (compute) | N/A | Medium | 🔜 Infra ready |
+| 12 | **NPU acceleration** | N/A (compute) | N/A | High | 🔬 Exploratory |
+| 13 | **WASM edge runtime** | N/A (deployment) | N/A | High | 🔬 Exploratory |
+| 14 | **Structured concurrency** | N/A (runtime) | N/A | Low | ✅ Done |