multilingual-rag-mcp 0.1.0__tar.gz

multilingual_rag_mcp-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,20 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: pip install -e ".[test]"
+      - run: pytest

multilingual_rag_mcp-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,21 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags: ["v*"]
+
+permissions:
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install build
+      - run: python -m build
+      - uses: pypa/gh-action-pypi-publish@release/v1

multilingual_rag_mcp-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+.venv/
+*.egg
+.DS_Store

multilingual_rag_mcp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aliaksandr Kazarez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

multilingual_rag_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.5
+Name: multilingual-rag-mcp
+Version: 0.1.0
+Summary: Multilingual RAG MCP server — cross-lingual search over local documents
+Project-URL: Repository, https://github.com/aliaksandr-kazarez/multilingual-rag-mcp
+Project-URL: Issues, https://github.com/aliaksandr-kazarez/multilingual-rag-mcp/issues
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cross-lingual,mcp,multilingual,rag,semantic-search
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Text Processing :: Indexing
+Requires-Python: >=3.11
+Requires-Dist: chromadb>=1.0
+Requires-Dist: fastembed>=0.4
+Requires-Dist: mcp<3.0,>=2.0
+Requires-Dist: pymupdf>=1.23
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# multilingual-rag-mcp
+
+Multilingual RAG MCP server for local document search. Query in one language, find content in another.
+
+Built for the common case where you talk to AI agents in English but your documents are in Russian (or any other language). The multilingual embedding model maps semantically similar concepts across 50+ languages to the same vector space — no translation step needed.
+
+## Install
+
+### pip from PyPI
+
+```bash
+pip install multilingual-rag-mcp
+```
+
+### One-liner with uvx (no install needed)
+
+```bash
+uvx --from multilingual-rag-mcp rag-mcp index ./docs/
+```
+
+### pip from GitHub (latest)
+
+```bash
+pip install git+https://github.com/aliaksandr-kazarez/multilingual-rag-mcp.git
+```
+
+## Quick start
+
+### 1. Index your documents
+
+```bash
+rag-mcp index ~/documents/
+```
+
+### 2. Add to Claude Code
+
+```bash
+claude mcp add rag -- uvx --from multilingual-rag-mcp rag-mcp
+```
+
+Set the document paths via env vars:
+
+```bash
+claude mcp add rag \
+  -e RAG_DOCS=$HOME/documents \
+  -- uvx --from multilingual-rag-mcp rag-mcp
+```
+
+If installed locally (pip install), use the simpler form:
+
+```bash
+claude mcp add rag -e RAG_DOCS=$HOME/documents -- rag-mcp
+```
+
+### 3. Search
+
+From Claude Code, the `search` tool handles cross-lingual queries automatically:
+
+- "search for protein recommendations" finds Russian articles about белок
+- "найди рецепты" finds recipe content regardless of language
+
+## MCP tools
+
+| Tool | Description |
+|------|-------------|
+| `search(query, n=5)` | Semantic search across all indexed documents |
+| `get_document(path)` | Retrieve full document content |
+| `list_documents(filter?)` | List indexed documents, optionally filtered |
+| `reindex()` | Re-index all configured document directories |
+| `stats()` | Index statistics (documents, chunks, categories) |
+
+## Configuration
+
+| Env var | Default | Description |
+|---------|---------|-------------|
+| `RAG_DOCS` | — | Comma-separated paths to document directories |
+| `RAG_DATA` | `~/.local/share/rag-mcp/` | Index storage location |
+| `RAG_MODEL` | `sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2` | Embedding model (any fastembed-compatible model) |
+| `RAG_CHUNK_SIZE` | `1000` | Maximum chunk size in characters |
+| `RAG_CHUNK_OVERLAP` | `200` | Overlap between chunks |
+
+## Supported formats
+
+Markdown (`.md`), plain text (`.txt`), PDF (`.pdf`), JSON (`.json`), CSV (`.csv`).
+
+Markdown files with YAML frontmatter have their metadata (title, date, etc.) extracted automatically.
+
+## CLI
+
+```
+rag-mcp index <dir> [<dir> ...]   Index documents
+rag-mcp stats                     Print index statistics
+rag-mcp                           Start MCP server (stdio)
+rag-mcp --help                    Show help
+rag-mcp --version                 Show version
+```
+
+## How it works
+
+1. Documents are parsed and split into chunks (markdown-aware: respects headers, code blocks)
+2. Each chunk is embedded with a multilingual model via [fastembed](https://github.com/qdrant/fastembed) (ONNX, no PyTorch needed)
+3. Embeddings are stored in [ChromaDB](https://www.trychroma.com/) (local, file-based)
+4. Queries are embedded with the same model and matched by cosine similarity
+5. Cross-lingual retrieval works because the model places semantically similar text from different languages near each other in vector space
+
+## License
+
+MIT

multilingual_rag_mcp-0.1.0/README.md

@@ -0,0 +1,108 @@
+# multilingual-rag-mcp
+
+Multilingual RAG MCP server for local document search. Query in one language, find content in another.
+
+Built for the common case where you talk to AI agents in English but your documents are in Russian (or any other language). The multilingual embedding model maps semantically similar concepts across 50+ languages to the same vector space — no translation step needed.
+
+## Install
+
+### pip from PyPI
+
+```bash
+pip install multilingual-rag-mcp
+```
+
+### One-liner with uvx (no install needed)
+
+```bash
+uvx --from multilingual-rag-mcp rag-mcp index ./docs/
+```
+
+### pip from GitHub (latest)
+
+```bash
+pip install git+https://github.com/aliaksandr-kazarez/multilingual-rag-mcp.git
+```
+
+## Quick start
+
+### 1. Index your documents
+
+```bash
+rag-mcp index ~/documents/
+```
+
+### 2. Add to Claude Code
+
+```bash
+claude mcp add rag -- uvx --from multilingual-rag-mcp rag-mcp
+```
+
+Set the document paths via env vars:
+
+```bash
+claude mcp add rag \
+  -e RAG_DOCS=$HOME/documents \
+  -- uvx --from multilingual-rag-mcp rag-mcp
+```
+
+If installed locally (pip install), use the simpler form:
+
+```bash
+claude mcp add rag -e RAG_DOCS=$HOME/documents -- rag-mcp
+```
+
+### 3. Search
+
+From Claude Code, the `search` tool handles cross-lingual queries automatically:
+
+- "search for protein recommendations" finds Russian articles about белок
+- "найди рецепты" finds recipe content regardless of language
+
+## MCP tools
+
+| Tool | Description |
+|------|-------------|
+| `search(query, n=5)` | Semantic search across all indexed documents |
+| `get_document(path)` | Retrieve full document content |
+| `list_documents(filter?)` | List indexed documents, optionally filtered |
+| `reindex()` | Re-index all configured document directories |
+| `stats()` | Index statistics (documents, chunks, categories) |
+
+## Configuration
+
+| Env var | Default | Description |
+|---------|---------|-------------|
+| `RAG_DOCS` | — | Comma-separated paths to document directories |
+| `RAG_DATA` | `~/.local/share/rag-mcp/` | Index storage location |
+| `RAG_MODEL` | `sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2` | Embedding model (any fastembed-compatible model) |
+| `RAG_CHUNK_SIZE` | `1000` | Maximum chunk size in characters |
+| `RAG_CHUNK_OVERLAP` | `200` | Overlap between chunks |
+
+## Supported formats
+
+Markdown (`.md`), plain text (`.txt`), PDF (`.pdf`), JSON (`.json`), CSV (`.csv`).
+
+Markdown files with YAML frontmatter have their metadata (title, date, etc.) extracted automatically.
+
+## CLI
+
+```
+rag-mcp index <dir> [<dir> ...]   Index documents
+rag-mcp stats                     Print index statistics
+rag-mcp                           Start MCP server (stdio)
+rag-mcp --help                    Show help
+rag-mcp --version                 Show version
+```
+
+## How it works
+
+1. Documents are parsed and split into chunks (markdown-aware: respects headers, code blocks)
+2. Each chunk is embedded with a multilingual model via [fastembed](https://github.com/qdrant/fastembed) (ONNX, no PyTorch needed)
+3. Embeddings are stored in [ChromaDB](https://www.trychroma.com/) (local, file-based)
+4. Queries are embedded with the same model and matched by cosine similarity
+5. Cross-lingual retrieval works because the model places semantically similar text from different languages near each other in vector space
+
+## License
+
+MIT

multilingual_rag_mcp-0.1.0/multilingual_rag_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""Multilingual RAG MCP server — cross-lingual search over local documents."""
+
+__version__ = "0.1.0"

multilingual_rag_mcp-0.1.0/multilingual_rag_mcp/__main__.py

@@ -0,0 +1,36 @@
+import sys
+
+
+def main():
+    if len(sys.argv) > 1 and sys.argv[1] in ("-h", "--help", "help"):
+        print(
+            "Usage: rag-mcp [command]\n"
+            "\n"
+            "Commands:\n"
+            "  index <dir> [<dir> ...]   Index documents from directories\n"
+            "  stats                     Print index statistics\n"
+            "  (none)                    Start MCP server (stdio)\n"
+            "\n"
+            "Environment:\n"
+            "  RAG_DOCS     Comma-separated document directories\n"
+            "  RAG_DATA     Index storage (default: ~/.local/share/rag-mcp/)\n"
+            "  RAG_MODEL    Embedding model (default: paraphrase-multilingual-MiniLM-L12-v2)\n"
+        )
+    elif len(sys.argv) > 1 and sys.argv[1] in ("-V", "--version"):
+        from multilingual_rag_mcp import __version__
+        print(f"rag-mcp {__version__}")
+    elif len(sys.argv) > 1 and sys.argv[1] == "index":
+        from multilingual_rag_mcp.ingest import index_cli
+        index_cli(sys.argv[2:])
+    elif len(sys.argv) > 1 and sys.argv[1] == "stats":
+        from multilingual_rag_mcp.store import VectorStore
+        import json
+        store = VectorStore()
+        print(json.dumps(store.stats(), indent=2, ensure_ascii=False))
+    else:
+        from multilingual_rag_mcp.server import mcp
+        mcp.run()
+
+
+if __name__ == "__main__":
+    main()

multilingual_rag_mcp-0.1.0/multilingual_rag_mcp/ingest.py

@@ -0,0 +1,201 @@
+"""Document parsing, chunking, and indexing."""
+from __future__ import annotations
+
+import json
+import re
+import sys
+from pathlib import Path
+
+SUPPORTED = {".md", ".txt", ".pdf", ".json", ".csv"}
+
+
+def parse_file(path: Path) -> tuple[str, dict]:
+    """Parse a file → (text, metadata). Strips markdown frontmatter into metadata."""
+    meta: dict = {"source": str(path), "filename": path.name}
+    suffix = path.suffix.lower()
+
+    if suffix == ".pdf":
+        import pymupdf
+
+        doc = pymupdf.open(str(path))
+        text = "\n\n".join(page.get_text() for page in doc)
+        meta["title"] = doc.metadata.get("title") or path.stem
+        doc.close()
+        return text, meta
+
+    raw = path.read_text(encoding="utf-8", errors="replace")
+
+    if suffix == ".json":
+        try:
+            data = json.loads(raw)
+            text = json.dumps(data, indent=2, ensure_ascii=False)
+        except json.JSONDecodeError:
+            text = raw
+        meta["title"] = path.stem
+        return text, meta
+
+    if suffix == ".md":
+        text, fm = _strip_frontmatter(raw)
+        meta.update(fm)
+        if "title" not in meta:
+            meta["title"] = _first_heading(text) or path.stem
+    else:
+        text = raw
+        meta["title"] = path.stem
+
+    return text, meta
+
+
+def _strip_frontmatter(text: str) -> tuple[str, dict]:
+    """Remove YAML frontmatter and return (body, parsed fields)."""
+    if not text.startswith("---"):
+        return text, {}
+    end = text.find("\n---", 3)
+    if end < 0:
+        return text, {}
+    fm_block = text[3:end]
+    body = text[end + 4 :].strip()
+    fields: dict = {}
+    for line in fm_block.splitlines():
+        if ":" in line:
+            key, val = line.split(":", 1)
+            fields[key.strip()] = val.strip().strip("\"'")
+    return body, fields
+
+
+def _first_heading(text: str) -> str | None:
+    for line in text.splitlines():
+        if line.startswith("# "):
+            return line[2:].strip()
+    return None
+
+
+def chunk_markdown(text: str, max_size: int = 1000, overlap: int = 200) -> list[str]:
+    """Split markdown into chunks, respecting headers and code blocks."""
+    sections = re.split(r"(?=^#{1,3} )", text, flags=re.MULTILINE)
+    chunks: list[str] = []
+    for section in sections:
+        section = section.strip()
+        if not section:
+            continue
+        if len(section) <= max_size:
+            if len(section) > 30:
+                chunks.append(section)
+        else:
+            chunks.extend(_split_paragraphs(section, max_size, overlap))
+    return chunks
+
+
+def _split_paragraphs(
+    text: str, max_size: int = 1000, overlap: int = 200
+) -> list[str]:
+    paragraphs = re.split(r"\n\s*\n", text)
+    chunks: list[str] = []
+    current = ""
+    for para in paragraphs:
+        para = para.strip()
+        if not para:
+            continue
+        if len(current) + len(para) + 2 > max_size and current:
+            chunks.append(current.strip())
+            tail = current[-overlap:].strip() if overlap else ""
+            current = (tail + "\n\n" + para) if tail else para
+        else:
+            current = (current + "\n\n" + para) if current else para
+    if current.strip() and len(current.strip()) > 30:
+        chunks.append(current.strip())
+    return chunks
+
+
+def doc_id_from_path(path: Path, base_dir: Path) -> str:
+    try:
+        return str(path.relative_to(base_dir))
+    except ValueError:
+        return str(path)
+
+
+def ingest_directory(
+    store,
+    docs_dir: Path,
+    *,
+    category: str = "",
+    chunk_size: int = 1000,
+    chunk_overlap: int = 200,
+) -> dict:
+    """Index all supported files under docs_dir."""
+    stats = {"indexed": 0, "chunks": 0, "skipped": 0, "errors": []}
+
+    for path in sorted(docs_dir.rglob("*")):
+        if not path.is_file():
+            continue
+        if path.suffix.lower() not in SUPPORTED:
+            continue
+        if any(part.startswith(".") for part in path.relative_to(docs_dir).parts):
+            continue
+
+        try:
+            text, meta = parse_file(path)
+            if not text or len(text.strip()) < 50:
+                stats["skipped"] += 1
+                continue
+
+            did = doc_id_from_path(path, docs_dir)
+            meta["doc_id"] = did
+            meta["category"] = category or docs_dir.name
+
+            chunks = chunk_markdown(text, chunk_size, chunk_overlap)
+            if not chunks:
+                stats["skipped"] += 1
+                continue
+
+            metadatas = [{**meta, "chunk_index": i} for i in range(len(chunks))]
+            store.add_chunks(did, chunks, metadatas)
+            stats["indexed"] += 1
+            stats["chunks"] += len(chunks)
+        except Exception as e:
+            stats["errors"].append(f"{path.name}: {e}")
+
+    return stats
+
+
+def index_cli(args: list[str]) -> None:
+    """CLI entry: `rag-mcp index /path/to/docs [/more/docs ...]`"""
+    import os
+
+    dirs = args or [
+        p.strip()
+        for p in os.environ.get("RAG_DOCS", "").split(",")
+        if p.strip()
+    ]
+    if not dirs:
+        print("Usage: rag-mcp index <docs_dir> [<docs_dir> ...]", file=sys.stderr)
+        print("   or: RAG_DOCS=/path/to/docs rag-mcp index", file=sys.stderr)
+        sys.exit(1)
+
+    from multilingual_rag_mcp.store import VectorStore
+
+    store = VectorStore()
+    chunk_size = int(os.environ.get("RAG_CHUNK_SIZE", "1000"))
+    chunk_overlap = int(os.environ.get("RAG_CHUNK_OVERLAP", "200"))
+
+    for d in dirs:
+        p = Path(d).expanduser().resolve()
+        if not p.is_dir():
+            print(f"SKIP {p}: not a directory", file=sys.stderr)
+            continue
+        print(f"Indexing {p} ...", file=sys.stderr)
+        s = ingest_directory(store, p, chunk_size=chunk_size, chunk_overlap=chunk_overlap)
+        print(
+            f"  {s['indexed']} docs, {s['chunks']} chunks, "
+            f"{s['skipped']} skipped, {len(s['errors'])} errors",
+            file=sys.stderr,
+        )
+        for err in s["errors"][:10]:
+            print(f"  ERROR: {err}", file=sys.stderr)
+
+    total = store.stats()
+    print(
+        f"\nDone. {total['total_documents']} documents, "
+        f"{total['total_chunks']} chunks in index.",
+        file=sys.stderr,
+    )

multilingual_rag_mcp-0.1.0/multilingual_rag_mcp/server.py

@@ -0,0 +1,135 @@
+"""MCP server exposing multilingual RAG search tools."""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+from multilingual_rag_mcp.ingest import ingest_directory, parse_file
+from multilingual_rag_mcp.store import VectorStore
+
+mcp = FastMCP("rag-mcp")
+
+_store: VectorStore | None = None
+
+
+def _get_store() -> VectorStore:
+    global _store
+    if _store is None:
+        _store = VectorStore()
+    return _store
+
+
+def _docs_dirs() -> list[Path]:
+    raw = os.environ.get("RAG_DOCS", "")
+    return [Path(p.strip()).expanduser().resolve() for p in raw.split(",") if p.strip()]
+
+
+@mcp.tool()
+def search(query: str, n: int = 5) -> str:
+    """Search the knowledge base with a natural-language query.
+
+    Works across languages: query in English to find Russian content,
+    or query in Russian to find English content. The multilingual
+    embedding model maps semantically similar concepts across languages.
+    """
+    store = _get_store()
+    results = store.search(query, n)
+    if not results:
+        return "No results found. If the index is empty, call the reindex tool first."
+
+    parts = []
+    for r in results:
+        meta = r["metadata"]
+        score = max(0, 1 - r["distance"])
+        parts.append(
+            f"### {meta.get('title', '?')} (score: {score:.2f})\n"
+            f"**Source:** {meta.get('source', '?')}  \n"
+            f"**Category:** {meta.get('category', '?')}\n\n"
+            f"{r['text']}\n"
+        )
+    return "\n---\n".join(parts)
+
+
+@mcp.tool()
+def get_document(path: str) -> str:
+    """Retrieve the full content of a source document by path.
+
+    Accepts an absolute path or a path relative to any configured RAG_DOCS directory.
+    """
+    p = Path(path)
+    if not p.exists():
+        for d in _docs_dirs():
+            candidate = d / path
+            if candidate.exists():
+                p = candidate
+                break
+        else:
+            return f"Not found: {path}"
+
+    text, meta = parse_file(p)
+    return f"# {meta.get('title', p.name)}\n\n{text}"
+
+
+@mcp.tool()
+def list_documents(filter: str | None = None) -> str:
+    """List indexed documents. Optionally filter by keyword in title or path."""
+    docs = _get_store().list_documents()
+    if filter:
+        fl = filter.lower()
+        docs = [
+            d
+            for d in docs
+            if fl in d["title"].lower() or fl in d["source"].lower()
+        ]
+
+    if not docs:
+        return "No documents indexed. Call reindex to populate the knowledge base."
+
+    lines = ["| Title | Category | Chunks |", "|---|---|---|"]
+    for d in docs:
+        lines.append(f"| {d['title'][:60]} | {d['category'][:20]} | {d['chunks']} |")
+    lines.append(f"\n**Total: {len(docs)} documents**")
+    return "\n".join(lines)
+
+
+@mcp.tool()
+def reindex() -> str:
+    """Re-index all documents from the configured RAG_DOCS directories."""
+    dirs = _docs_dirs()
+    if not dirs:
+        return (
+            "No RAG_DOCS configured. Set the RAG_DOCS environment variable to a "
+            "comma-separated list of directories containing your documents."
+        )
+
+    store = _get_store()
+    chunk_size = int(os.environ.get("RAG_CHUNK_SIZE", "1000"))
+    chunk_overlap = int(os.environ.get("RAG_CHUNK_OVERLAP", "200"))
+
+    results = []
+    for d in dirs:
+        if not d.is_dir():
+            results.append(f"{d}: not a directory, skipped")
+            continue
+        s = ingest_directory(store, d, chunk_size=chunk_size, chunk_overlap=chunk_overlap)
+        results.append(
+            f"{d.name}: {s['indexed']} docs, {s['chunks']} chunks, "
+            f"{s['skipped']} skipped, {len(s['errors'])} errors"
+        )
+        for err in s["errors"][:5]:
+            results.append(f"  ERROR: {err}")
+
+    total = store.stats()
+    results.append(
+        f"\nTotal: {total['total_documents']} documents, {total['total_chunks']} chunks"
+    )
+    return "\n".join(results)
+
+
+@mcp.tool()
+def stats() -> str:
+    """Get knowledge base statistics: document count, chunk count, categories."""
+    return json.dumps(_get_store().stats(), indent=2, ensure_ascii=False)

multilingual_rag_mcp-0.1.0/multilingual_rag_mcp/store.py

@@ -0,0 +1,106 @@
+"""Vector store backed by ChromaDB with multilingual embeddings."""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import chromadb
+from chromadb.api.types import Documents, EmbeddingFunction, Embeddings
+
+DEFAULT_MODEL = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
+DEFAULT_DATA_DIR = Path.home() / ".local" / "share" / "rag-mcp"
+
+
+class _FastEmbedEF(EmbeddingFunction[Documents]):
+    def __init__(self, model_name: str):
+        from fastembed import TextEmbedding
+
+        self._model = TextEmbedding(model_name=model_name)
+
+    def __call__(self, input: Documents) -> Embeddings:
+        return [e.tolist() for e in self._model.embed(list(input))]
+
+
+class VectorStore:
+    def __init__(
+        self,
+        data_dir: str | Path | None = None,
+        model: str | None = None,
+    ):
+        data_dir = Path(data_dir or os.environ.get("RAG_DATA", str(DEFAULT_DATA_DIR)))
+        data_dir.mkdir(parents=True, exist_ok=True)
+        self._model_name = model or os.environ.get("RAG_MODEL", DEFAULT_MODEL)
+
+        self._ef = _FastEmbedEF(self._model_name)
+        self._client = chromadb.PersistentClient(path=str(data_dir / "chroma"))
+        self._col = self._client.get_or_create_collection(
+            name="documents",
+            embedding_function=self._ef,
+            metadata={"hnsw:space": "cosine"},
+        )
+
+    def add_chunks(
+        self, doc_id: str, chunks: list[str], metadatas: list[dict]
+    ) -> None:
+        ids = [f"{doc_id}::{i}" for i in range(len(chunks))]
+        self._col.upsert(ids=ids, documents=chunks, metadatas=metadatas)
+
+    def remove_document(self, doc_id: str) -> int:
+        existing = self._col.get(where={"doc_id": doc_id})
+        if existing["ids"]:
+            self._col.delete(ids=existing["ids"])
+        return len(existing["ids"])
+
+    def search(self, query: str, n: int = 5) -> list[dict]:
+        if self._col.count() == 0:
+            return []
+        # Fetch extra candidates to deduplicate by document
+        fetch_n = min(n * 3, self._col.count())
+        results = self._col.query(query_texts=[query], n_results=fetch_n)
+        out = []
+        seen_docs: set[str] = set()
+        for i in range(len(results["ids"][0])):
+            doc_id = results["metadatas"][0][i].get("doc_id", "")
+            if doc_id in seen_docs:
+                continue
+            seen_docs.add(doc_id)
+            out.append(
+                {
+                    "id": results["ids"][0][i],
+                    "text": results["documents"][0][i],
+                    "metadata": results["metadatas"][0][i],
+                    "distance": results["distances"][0][i],
+                }
+            )
+            if len(out) >= n:
+                break
+        return out
+
+    def list_documents(self) -> list[dict]:
+        all_data = self._col.get(include=["metadatas"])
+        docs: dict[str, dict] = {}
+        for m in all_data["metadatas"]:
+            doc_id = m.get("doc_id", "?")
+            if doc_id not in docs:
+                docs[doc_id] = {
+                    "doc_id": doc_id,
+                    "title": m.get("title", ""),
+                    "source": m.get("source", ""),
+                    "category": m.get("category", ""),
+                    "chunks": 0,
+                }
+            docs[doc_id]["chunks"] += 1
+        return sorted(docs.values(), key=lambda d: d["source"])
+
+    def stats(self) -> dict:
+        docs = self.list_documents()
+        categories = {}
+        for d in docs:
+            cat = d.get("category", "uncategorized") or "uncategorized"
+            categories[cat] = categories.get(cat, 0) + 1
+        return {
+            "total_chunks": self._col.count(),
+            "total_documents": len(docs),
+            "categories": categories,
+            "model": self._model_name,
+        }

multilingual_rag_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "multilingual-rag-mcp"
+version = "0.1.0"
+description = "Multilingual RAG MCP server — cross-lingual search over local documents"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.11"
+keywords = ["mcp", "rag", "multilingual", "semantic-search", "cross-lingual"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Text Processing :: Indexing",
+]
+dependencies = [
+    "mcp>=2.0,<3.0",
+    "chromadb>=1.0",
+    "fastembed>=0.4",
+    "pymupdf>=1.23",
+]
+
+[project.optional-dependencies]
+test = ["pytest>=8.0"]
+
+[project.urls]
+Repository = "https://github.com/aliaksandr-kazarez/multilingual-rag-mcp"
+Issues = "https://github.com/aliaksandr-kazarez/multilingual-rag-mcp/issues"
+
+[project.scripts]
+rag-mcp = "multilingual_rag_mcp.__main__:main"

multilingual_rag_mcp-0.1.0/tests/test_smoke.py

@@ -0,0 +1,69 @@
+import subprocess
+import sys
+
+import pytest
+
+
+def test_version_import():
+    from multilingual_rag_mcp import __version__
+    assert __version__ == "0.1.0"
+
+
+def test_cli_version():
+    result = subprocess.run(
+        [sys.executable, "-m", "multilingual_rag_mcp", "--version"],
+        capture_output=True, text=True,
+    )
+    assert result.returncode == 0
+    assert "rag-mcp 0.1.0" in result.stdout
+
+
+def test_cli_help():
+    result = subprocess.run(
+        [sys.executable, "-m", "multilingual_rag_mcp", "--help"],
+        capture_output=True, text=True,
+    )
+    assert result.returncode == 0
+    assert "index" in result.stdout
+    assert "stats" in result.stdout
+
+
+def test_store_defaults():
+    from multilingual_rag_mcp.store import DEFAULT_MODEL, DEFAULT_DATA_DIR
+    assert "multilingual" in DEFAULT_MODEL
+    assert "rag-mcp" in str(DEFAULT_DATA_DIR)
+
+
+def test_ingest_supported_formats():
+    from multilingual_rag_mcp.ingest import SUPPORTED
+    assert ".md" in SUPPORTED
+    assert ".pdf" in SUPPORTED
+    assert ".txt" in SUPPORTED
+
+
+def test_chunk_markdown():
+    from multilingual_rag_mcp.ingest import chunk_markdown
+    text = (
+        "# Title\n\n"
+        "This is the first paragraph with enough content to pass the length filter.\n\n"
+        "## Section\n\n"
+        "This is the second paragraph with enough content to pass the length filter."
+    )
+    chunks = chunk_markdown(text, max_size=1000, overlap=0)
+    assert len(chunks) >= 1
+    assert any("first paragraph" in c for c in chunks)
+
+
+def test_parse_markdown_frontmatter():
+    import tempfile
+    from pathlib import Path
+    from multilingual_rag_mcp.ingest import parse_file
+
+    content = "---\ntitle: Test\ndate: 2025-01-01\n---\n\n# Hello\n\nBody text."
+    with tempfile.NamedTemporaryFile(suffix=".md", mode="w", delete=False) as f:
+        f.write(content)
+        f.flush()
+        text, meta = parse_file(Path(f.name))
+
+    assert "Body text" in text
+    assert meta.get("title") == "Test"