fusesearch 0.1.0__tar.gz

fusesearch-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anton Lebedev
+
+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.

fusesearch-0.1.0/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: fusesearch
+Version: 0.1.0
+Summary: Multi-source search aggregation tool with AI-powered retrieval and response synthesis
+Author-email: Anton Lebedev <pypi@katzo.net>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.12
+Requires-Dist: qdrant-client>=1.16
+Requires-Dist: fastapi>=0.129
+Requires-Dist: uvicorn>=0.40
+Requires-Dist: tqdm>=4.67
+Provides-Extra: mcp
+Requires-Dist: mcp[cli]>=1.26; extra == "mcp"
+Provides-Extra: local
+Requires-Dist: sentence-transformers>=5.2; extra == "local"
+Provides-Extra: all
+Requires-Dist: fusesearch[local,mcp]; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=9.0; extra == "dev"
+Requires-Dist: ruff>=0.15; extra == "dev"
+Dynamic: license-file
+
+# FuseSearch
+
+Multi-source search aggregation tool that unifies retrieval across diverse data sources — Confluence, MCP servers, local files, and more — using AI-powered search and response synthesis through a single query interface.
+
+## Quick Start
+
+```bash
+make build
+make start
+make index    # index docs from data/docs
+make search "your query"
+```
+
+## MCP Server
+
+The `fusesearch-mcp` Docker service exposes a streamable HTTP endpoint on port 8001. Tools: `search` (hybrid search), `count` (indexed chunks).
+
+### Claude Code
+
+```bash
+claude mcp add fusesearch http://localhost:8001/mcp --transport http
+```
+
+### Claude Desktop
+
+**Option 1: Connectors UI (recommended)**
+
+In Claude Desktop, go to **Settings > Connectors > Add custom connector** and enter `https://localhost:8001/mcp`.
+
+**Option 2: Config file with `mcp-remote` bridge (local dev)**
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "fusesearch": {
+      "command": "npx",
+      "args": ["-y", "mcp-remote", "http://localhost:8001/mcp", "--allow-http"]
+    }
+  }
+}
+```
+
+Requires Node.js >= 18. `--allow-http` is required for plain HTTP (not needed for HTTPS).

fusesearch-0.1.0/README.md

@@ -0,0 +1,45 @@
+# FuseSearch
+
+Multi-source search aggregation tool that unifies retrieval across diverse data sources — Confluence, MCP servers, local files, and more — using AI-powered search and response synthesis through a single query interface.
+
+## Quick Start
+
+```bash
+make build
+make start
+make index    # index docs from data/docs
+make search "your query"
+```
+
+## MCP Server
+
+The `fusesearch-mcp` Docker service exposes a streamable HTTP endpoint on port 8001. Tools: `search` (hybrid search), `count` (indexed chunks).
+
+### Claude Code
+
+```bash
+claude mcp add fusesearch http://localhost:8001/mcp --transport http
+```
+
+### Claude Desktop
+
+**Option 1: Connectors UI (recommended)**
+
+In Claude Desktop, go to **Settings > Connectors > Add custom connector** and enter `https://localhost:8001/mcp`.
+
+**Option 2: Config file with `mcp-remote` bridge (local dev)**
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "fusesearch": {
+      "command": "npx",
+      "args": ["-y", "mcp-remote", "http://localhost:8001/mcp", "--allow-http"]
+    }
+  }
+}
+```
+
+Requires Node.js >= 18. `--allow-http` is required for plain HTTP (not needed for HTTPS).

fusesearch-0.1.0/fusesearch/__main__.py

@@ -0,0 +1,120 @@
+import argparse
+import os
+
+
+def _make_embedder():
+    from fusesearch.core.embedder import LocalEmbedder
+
+    return LocalEmbedder()
+
+
+def _make_store(embedder):
+    from fusesearch.store.qdrant import QdrantStore
+
+    return QdrantStore(
+        host=os.getenv("QDRANT_HOST", "localhost"),
+        port=int(os.getenv("QDRANT_PORT", "6333")),
+        dimension=embedder.dimension,
+    )
+
+
+def cmd_serve(args):
+    import uvicorn
+
+    host = args.host or os.getenv("FUSESEARCH_HOST", "0.0.0.0")
+    port = int(args.port or os.getenv("FUSESEARCH_PORT", "8000"))
+    uvicorn.run("fusesearch.api.server:app", host=host, port=port)
+
+
+def cmd_index(args):
+    from fusesearch.indexer import Indexer
+    from fusesearch.sources.local_files import LocalFilesAdapter
+
+    embedder = _make_embedder()
+    store = _make_store(embedder)
+
+    adapter = LocalFilesAdapter(directories=args.paths)
+    documents = list(adapter.fetch())
+    print(f"Found {len(documents)} documents")
+
+    indexer = Indexer(store=store, embedder=embedder)
+    stats = indexer.index_documents(documents)
+    print(
+        f"Indexed: {stats['new']} new, {stats['skipped']} skipped, {stats['deleted']} deleted"
+    )
+    print(f"Total chunks in store: {store.count()}")
+
+
+def cmd_search(args):
+    embedder = _make_embedder()
+    store = _make_store(embedder)
+    hybrid = not args.no_hybrid
+
+    query_vector = embedder.embed_one(args.query)
+    if hybrid:
+        results = store.hybrid_search(query_vector, args.query, limit=args.limit)
+    else:
+        results = store.search(query_vector, limit=args.limit)
+
+    mode = "hybrid" if hybrid else "vector-only"
+    print(f"Search mode: {mode}")
+    for i, result in enumerate(results, 1):
+        print(f"\n--- Result {i} (score: {result['score']:.4f}) ---")
+        print(f"Title: {result['title']}")
+        if result["heading_path"]:
+            print(f"Section: {' > '.join(result['heading_path'])}")
+        print(f"Content: {result['content'][:300]}...")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="fusesearch", description="FuseSearch - multi-source search"
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    # Serve command (default)
+    serve_parser = subparsers.add_parser("serve", help="Start the API server")
+    serve_parser.add_argument("--host", default=None, help="Host to bind to")
+    serve_parser.add_argument("--port", default=None, help="Port to bind to")
+
+    # Index command
+    index_parser = subparsers.add_parser(
+        "index", help="Index documents from local files"
+    )
+    index_parser.add_argument("paths", nargs="+", help="Directories to index")
+
+    # Search command
+    search_parser = subparsers.add_parser("search", help="Search indexed documents")
+    search_parser.add_argument("query", help="Search query")
+    search_parser.add_argument("--limit", type=int, default=5, help="Number of results")
+    search_parser.add_argument(
+        "--no-hybrid", action="store_true", help="Disable hybrid search (vector-only)"
+    )
+
+    # MCP server command
+    mcp_parser = subparsers.add_parser("mcp", help="Start the MCP server")
+    mcp_parser.add_argument(
+        "--transport",
+        choices=["stdio", "sse", "streamable-http"],
+        default="stdio",
+        help="Transport type",
+    )
+
+    args = parser.parse_args()
+
+    if args.command == "serve":
+        cmd_serve(args)
+    elif args.command == "index":
+        cmd_index(args)
+    elif args.command == "search":
+        cmd_search(args)
+    elif args.command == "mcp":
+        from fusesearch.mcp_server import main as mcp_main
+
+        mcp_main(transport=args.transport)
+    else:
+        cmd_serve(argparse.Namespace(host=None, port=None))
+
+
+if __name__ == "__main__":
+    main()

fusesearch-0.1.0/fusesearch/api/server.py

@@ -0,0 +1,54 @@
+import os
+
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+from fusesearch.core.embedder import LocalEmbedder
+from fusesearch.indexer import Indexer
+from fusesearch.sources.local_files import LocalFilesAdapter
+from fusesearch.store.qdrant import QdrantStore
+
+app = FastAPI(title="FuseSearch", version="0.1.0")
+
+embedder = LocalEmbedder()
+
+qdrant_host = os.getenv("QDRANT_HOST", "localhost")
+qdrant_port = int(os.getenv("QDRANT_PORT", "6333"))
+store = QdrantStore(host=qdrant_host, port=qdrant_port, dimension=embedder.dimension)
+indexer = Indexer(store=store, embedder=embedder)
+
+
+class SearchRequest(BaseModel):
+    query: str
+    limit: int = 5
+    hybrid: bool = True
+    vector_weight: float = 0.7
+
+
+class IndexRequest(BaseModel):
+    paths: list[str]
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok", "chunks_indexed": store.count()}
+
+
+@app.post("/search")
+def search(req: SearchRequest):
+    query_vector = embedder.embed_one(req.query)
+    if req.hybrid:
+        results = store.hybrid_search(
+            query_vector, req.query, limit=req.limit, vector_weight=req.vector_weight
+        )
+    else:
+        results = store.search(query_vector, limit=req.limit)
+    return {"results": results}
+
+
+@app.post("/index")
+def index(req: IndexRequest):
+    adapter = LocalFilesAdapter(directories=req.paths)
+    documents = list(adapter.fetch())
+    stats = indexer.index_documents(documents)
+    return {"documents_found": len(documents), **stats}

fusesearch-0.1.0/fusesearch/core/chunker.py

@@ -0,0 +1,89 @@
+import re
+
+from fusesearch.models import Chunk, Document
+
+HEADING_PATTERN = re.compile(r"^(#{1,6})\s+(.+)$", re.MULTILINE)
+
+
+def chunk_document(document: Document, max_chunk_size: int = 1000) -> list[Chunk]:
+    """Split a document into chunks by markdown headings.
+
+    Splits on headings first (semantic boundaries), then splits
+    oversized sections by paragraphs.
+    """
+    sections = _split_by_headings(document.content)
+    chunks: list[Chunk] = []
+
+    for heading_path, content in sections:
+        for piece in _split_by_size(content, max_chunk_size):
+            chunk = Chunk(
+                document_source_id=document.source_id,
+                source_type=document.source_type,
+                title=document.title,
+                content=piece.strip(),
+                url=document.url,
+                metadata=document.metadata,
+                heading_path=heading_path,
+                chunk_index=len(chunks),
+            )
+            if chunk.content:
+                chunks.append(chunk)
+
+    return chunks
+
+
+def _split_by_headings(text: str) -> list[tuple[list[str], str]]:
+    """Split markdown text by headings, tracking the heading hierarchy."""
+    matches = list(HEADING_PATTERN.finditer(text))
+
+    if not matches:
+        return [([], text)]
+
+    sections: list[tuple[list[str], str]] = []
+    heading_stack: list[tuple[int, str]] = []
+
+    # Content before the first heading
+    preamble = text[: matches[0].start()].strip()
+    if preamble:
+        sections.append(([], preamble))
+
+    for i, match in enumerate(matches):
+        level = len(match.group(1))
+        title = match.group(2).strip()
+
+        # Update heading stack — pop headings at same or deeper level
+        heading_stack = [(lvl, t) for lvl, t in heading_stack if lvl < level]
+        heading_stack.append((level, title))
+
+        # Extract content between this heading and the next
+        start = match.end()
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
+        content = text[start:end].strip()
+
+        if content:
+            path = [t for _, t in heading_stack]
+            sections.append((path, content))
+
+    return sections
+
+
+def _split_by_size(text: str, max_size: int) -> list[str]:
+    """Split text into pieces that fit within max_size, splitting on paragraphs."""
+    if len(text) <= max_size:
+        return [text]
+
+    paragraphs = text.split("\n\n")
+    pieces: list[str] = []
+    current = ""
+
+    for paragraph in paragraphs:
+        if current and len(current) + len(paragraph) + 2 > max_size:
+            pieces.append(current)
+            current = paragraph
+        else:
+            current = f"{current}\n\n{paragraph}" if current else paragraph
+
+    if current:
+        pieces.append(current)
+
+    return pieces

fusesearch-0.1.0/fusesearch/core/embedder.py

@@ -0,0 +1,37 @@
+import os
+from abc import ABC, abstractmethod
+
+
+class Embedder(ABC):
+    """Abstract base class for embedding providers."""
+
+    @property
+    @abstractmethod
+    def dimension(self) -> int:
+        """Dimension of the embedding vectors."""
+
+    @abstractmethod
+    def embed(self, texts: list[str]) -> list[list[float]]:
+        """Generate embeddings for a batch of texts."""
+
+    def embed_one(self, text: str) -> list[float]:
+        return self.embed([text])[0]
+
+
+class LocalEmbedder(Embedder):
+    """Local embedding provider using sentence-transformers."""
+
+    def __init__(self, model: str | None = None, local_files_only: bool = False):
+        from sentence_transformers import SentenceTransformer
+
+        model = model or os.getenv("FUSESEARCH_EMBED_MODEL", "all-MiniLM-L6-v2")
+        self.model = SentenceTransformer(model, local_files_only=local_files_only)
+        self._dimension = self.model.get_sentence_embedding_dimension()
+
+    @property
+    def dimension(self) -> int:
+        return self._dimension
+
+    def embed(self, texts: list[str]) -> list[list[float]]:
+        embeddings = self.model.encode(texts)
+        return embeddings.tolist()

fusesearch-0.1.0/fusesearch/indexer.py

@@ -0,0 +1,57 @@
+from tqdm import tqdm
+
+from fusesearch.core.chunker import chunk_document
+from fusesearch.core.embedder import Embedder
+from fusesearch.models import Chunk, Document
+from fusesearch.store.qdrant import QdrantStore, hash_to_uuid
+
+EMBED_BATCH_SIZE = 64
+
+
+class Indexer:
+    """Indexes documents into the vector store."""
+
+    def __init__(self, store: QdrantStore, embedder: Embedder):
+        self.store = store
+        self.embedder = embedder
+
+    def index_documents(self, documents: list[Document]) -> dict:
+        """Chunk, diff, embed, and store documents.
+
+        Returns stats: total_chunks, new, skipped, deleted.
+        """
+        # Chunk all documents
+        all_chunks: list[Chunk] = []
+        for doc in tqdm(documents, desc="Chunking", unit="doc"):
+            all_chunks.extend(chunk_document(doc))
+
+        # Diff against existing index
+        new_ids = {hash_to_uuid(chunk.content_hash) for chunk in all_chunks}
+        existing_ids = self.store.get_existing_hashes()
+
+        to_add = [
+            c for c in all_chunks if hash_to_uuid(c.content_hash) not in existing_ids
+        ]
+        to_delete = existing_ids - new_ids
+
+        # Delete removed chunks
+        if to_delete:
+            self.store.delete_by_hashes(to_delete)
+
+        # Embed and store new chunks in batches
+        if to_add:
+            pbar = tqdm(total=len(to_add), desc="Embedding", unit="chunk")
+            for i in range(0, len(to_add), EMBED_BATCH_SIZE):
+                batch = to_add[i : i + EMBED_BATCH_SIZE]
+                texts = [chunk.content for chunk in batch]
+                embeddings = self.embedder.embed(texts)
+                self.store.upsert(batch, embeddings)
+                pbar.update(len(batch))
+            pbar.close()
+
+        return {
+            "total_chunks": len(all_chunks),
+            "new": len(to_add),
+            "skipped": len(all_chunks) - len(to_add),
+            "deleted": len(to_delete),
+        }

fusesearch-0.1.0/fusesearch/mcp_server.py

@@ -0,0 +1,84 @@
+import os
+from typing import Literal
+
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP(
+    "FuseSearch",
+    instructions=(
+        "FuseSearch is a knowledge base with indexed documents, blog posts, and notes. "
+        "Use this server when the user asks factual questions, wants to look up a topic, "
+        "or needs information that might exist in indexed sources."
+    ),
+    host=os.getenv("MCP_HOST", "0.0.0.0"),
+    port=int(os.getenv("MCP_PORT", "8001")),
+)
+
+# Lazy-initialized globals
+_embedder = None
+_store = None
+
+
+def _get_embedder():
+    global _embedder
+    if _embedder is None:
+        from fusesearch.core.embedder import LocalEmbedder
+
+        _embedder = LocalEmbedder()
+    return _embedder
+
+
+def _get_store():
+    global _store
+    if _store is None:
+        from fusesearch.store.qdrant import QdrantStore
+
+        _store = QdrantStore(
+            host=os.getenv("QDRANT_HOST", "localhost"),
+            port=int(os.getenv("QDRANT_PORT", "6333")),
+            dimension=_get_embedder().dimension,
+        )
+    return _store
+
+
+@mcp.tool()
+def search(query: str, limit: int = 5) -> str:
+    """Search the FuseSearch knowledge base. Use this tool whenever the user asks a factual or knowledge question — about a topic, concept, person, event, or anything that indexed documents might answer. Returns relevant document chunks with source titles and scores. Always search BEFORE answering knowledge questions."""
+    embedder = _get_embedder()
+    store = _get_store()
+
+    query_vector = embedder.embed_one(query)
+    results = store.hybrid_search(query_vector, query, limit=limit)
+
+    if not results:
+        return "No results found."
+
+    parts = []
+    for i, result in enumerate(results, 1):
+        title = result.get("title", "Untitled")
+        heading = ""
+        if result.get("heading_path"):
+            heading = f" > {' > '.join(result['heading_path'])}"
+        score = result.get("score", 0)
+        content = result.get("content", "")
+        parts.append(f"[{i}] {title}{heading} (score: {score:.4f})\n{content}")
+
+    return "\n\n---\n\n".join(parts)
+
+
+@mcp.tool()
+def count() -> str:
+    """Return the number of indexed chunks in the store."""
+    store = _get_store()
+    return f"{store.count()} chunks indexed"
+
+
+Transport = Literal["stdio", "sse", "streamable-http"]
+
+
+def main(transport: Transport = "streamable-http"):
+    mcp.run(transport=transport)
+
+
+if __name__ == "__main__":
+    main()

fusesearch-0.1.0/fusesearch/models.py

@@ -0,0 +1,34 @@
+from datetime import datetime
+from hashlib import sha256
+
+from pydantic import BaseModel, Field, computed_field
+
+
+class Document(BaseModel):
+    """A normalized document from any source."""
+
+    source_type: str
+    source_id: str
+    title: str
+    content: str
+    url: str | None = None
+    metadata: dict = Field(default_factory=dict)
+    fetched_at: datetime = Field(default_factory=datetime.now)
+
+
+class Chunk(BaseModel):
+    """A piece of a document, ready for embedding and indexing."""
+
+    document_source_id: str
+    source_type: str
+    title: str
+    content: str
+    url: str | None = None
+    metadata: dict = Field(default_factory=dict)
+    heading_path: list[str] = Field(default_factory=list)
+    chunk_index: int = 0
+
+    @computed_field
+    @property
+    def content_hash(self) -> str:
+        return sha256(self.content.encode()).hexdigest()

fusesearch-0.1.0/fusesearch/sources/base.py

@@ -0,0 +1,25 @@
+from abc import ABC, abstractmethod
+from collections.abc import Iterator
+
+from fusesearch.models import Document
+
+
+class SourceAdapter(ABC):
+    """Abstract base class for all source adapters."""
+
+    @property
+    @abstractmethod
+    def source_type(self) -> str:
+        """Unique identifier for this source type (e.g. 'local_files')."""
+
+    @abstractmethod
+    def fetch(self) -> Iterator[Document]:
+        """Fetch all documents from this source."""
+
+    @abstractmethod
+    def fetch_updated(self, since: str | None = None) -> Iterator[Document]:
+        """Fetch only documents updated since the given cursor.
+
+        The cursor format is source-specific (e.g. timestamp, page token).
+        If None, behaves like fetch() (full sync).
+        """

fusesearch-0.1.0/fusesearch/sources/local_files.py

@@ -0,0 +1,59 @@
+from collections.abc import Iterator
+from datetime import datetime
+from pathlib import Path
+
+from fusesearch.models import Document
+from fusesearch.sources.base import SourceAdapter
+
+SUPPORTED_EXTENSIONS = {".md", ".txt", ".rst"}
+
+
+class LocalFilesAdapter(SourceAdapter):
+    """Source adapter for local markdown and text files."""
+
+    def __init__(self, directories: list[str | Path]):
+        self.directories = [Path(d) for d in directories]
+
+    @property
+    def source_type(self) -> str:
+        return "local_files"
+
+    def fetch(self) -> Iterator[Document]:
+        for directory in self.directories:
+            yield from self._scan_directory(directory)
+
+    def fetch_updated(self, since: str | None = None) -> Iterator[Document]:
+        if since is None:
+            yield from self.fetch()
+            return
+
+        cutoff = datetime.fromisoformat(since)
+        for document in self.fetch():
+            if document.fetched_at >= cutoff:
+                yield document
+
+    def _scan_directory(self, directory: Path) -> Iterator[Document]:
+        if not directory.is_dir():
+            return
+
+        for path in directory.rglob("*"):
+            if path.suffix not in SUPPORTED_EXTENSIONS:
+                continue
+            if not path.is_file():
+                continue
+
+            content = path.read_text(encoding="utf-8", errors="replace")
+            stat = path.stat()
+
+            yield Document(
+                source_type=self.source_type,
+                source_id=str(path.resolve()),
+                title=path.stem,
+                content=content,
+                metadata={
+                    "path": str(path.resolve()),
+                    "extension": path.suffix,
+                    "size_bytes": stat.st_size,
+                    "modified_at": datetime.fromtimestamp(stat.st_mtime).isoformat(),
+                },
+            )

fusesearch-0.1.0/fusesearch/store/qdrant.py

@@ -0,0 +1,187 @@
+import os
+import uuid
+
+from qdrant_client import QdrantClient
+from qdrant_client.models import (
+    Distance,
+    FieldCondition,
+    Filter,
+    MatchText,
+    PayloadSchemaType,
+    PointStruct,
+    VectorParams,
+)
+
+from fusesearch.models import Chunk
+
+
+def hash_to_uuid(content_hash: str) -> str:
+    """Convert a SHA-256 hex string to a UUID (uses first 32 hex chars)."""
+    return str(uuid.UUID(content_hash[:32]))
+
+
+class QdrantStore:
+    """Vector store backed by Qdrant."""
+
+    def __init__(self, host: str = "localhost", port: int = 6333, dimension: int = 384):
+        self.client = QdrantClient(host=host, port=port)
+        self.collection_name = os.getenv("FUSESEARCH_COLLECTION", "fusesearch")
+        self.dimension = dimension
+        self._ensure_collection()
+
+    def _ensure_collection(self):
+        collections = [c.name for c in self.client.get_collections().collections]
+        if self.collection_name not in collections:
+            self.client.create_collection(
+                collection_name=self.collection_name,
+                vectors_config=VectorParams(
+                    size=self.dimension,
+                    distance=Distance.COSINE,
+                ),
+            )
+        self._ensure_text_index()
+
+    def _ensure_text_index(self):
+        """Create a full-text index on the content field for keyword search."""
+        collection_info = self.client.get_collection(self.collection_name)
+        if "content" not in (collection_info.payload_schema or {}):
+            self.client.create_payload_index(
+                collection_name=self.collection_name,
+                field_name="content",
+                field_schema=PayloadSchemaType.TEXT,
+            )
+
+    def upsert(self, chunks: list[Chunk], embeddings: list[list[float]]):
+        """Insert or update chunks with their embeddings."""
+        points = [
+            PointStruct(
+                id=hash_to_uuid(chunk.content_hash),
+                vector=embedding,
+                payload={
+                    "content": chunk.content,
+                    "title": chunk.title,
+                    "source_type": chunk.source_type,
+                    "document_source_id": chunk.document_source_id,
+                    "heading_path": chunk.heading_path,
+                    "chunk_index": chunk.chunk_index,
+                    "url": chunk.url,
+                    "metadata": chunk.metadata,
+                },
+            )
+            for chunk, embedding in zip(chunks, embeddings)
+        ]
+        self.client.upsert(collection_name=self.collection_name, points=points)
+
+    def search(self, query_vector: list[float], limit: int = 5) -> list[dict]:
+        """Search for similar chunks by vector similarity."""
+        results = self.client.query_points(
+            collection_name=self.collection_name,
+            query=query_vector,
+            limit=limit,
+        )
+        return [
+            {
+                "_id": point.id,
+                "score": point.score,
+                "content": point.payload["content"],
+                "title": point.payload["title"],
+                "source_type": point.payload["source_type"],
+                "heading_path": point.payload["heading_path"],
+                "metadata": point.payload["metadata"],
+            }
+            for point in results.points
+        ]
+
+    def keyword_search(self, query: str, limit: int = 20) -> list[dict]:
+        """BM25 keyword search using Qdrant's full-text index."""
+        results, _ = self.client.scroll(
+            collection_name=self.collection_name,
+            scroll_filter=Filter(
+                must=[FieldCondition(key="content", match=MatchText(text=query))]
+            ),
+            limit=limit,
+            with_payload=True,
+            with_vectors=False,
+        )
+        return [
+            {
+                "_id": point.id,
+                "content": point.payload["content"],
+                "title": point.payload["title"],
+                "source_type": point.payload["source_type"],
+                "heading_path": point.payload["heading_path"],
+                "metadata": point.payload["metadata"],
+            }
+            for point in results
+        ]
+
+    def hybrid_search(
+        self,
+        query_vector: list[float],
+        query_text: str,
+        limit: int = 5,
+        vector_weight: float = 0.7,
+    ) -> list[dict]:
+        """Run vector + keyword search and fuse results with RRF."""
+        vector_results = self.search(query_vector, limit=limit * 2)
+        keyword_results = self.keyword_search(query_text, limit=limit * 2)
+        fused = self._rrf_fuse(vector_results, keyword_results, vector_weight)
+        return fused[:limit]
+
+    @staticmethod
+    def _rrf_fuse(
+        vector_results: list[dict],
+        keyword_results: list[dict],
+        vector_weight: float = 0.7,
+        k: int = 60,
+    ) -> list[dict]:
+        """Reciprocal Rank Fusion of two result lists."""
+        keyword_weight = 1.0 - vector_weight
+        scores: dict[str, float] = {}
+        result_map: dict[str, dict] = {}
+
+        for rank, result in enumerate(vector_results):
+            rid = str(result["_id"])
+            scores[rid] = scores.get(rid, 0) + vector_weight / (k + rank + 1)
+            result_map[rid] = result
+
+        for rank, result in enumerate(keyword_results):
+            rid = str(result["_id"])
+            scores[rid] = scores.get(rid, 0) + keyword_weight / (k + rank + 1)
+            if rid not in result_map:
+                result_map[rid] = result
+
+        ranked = sorted(scores.items(), key=lambda x: x[1], reverse=True)
+        return [{**result_map[rid], "score": score} for rid, score in ranked]
+
+    def get_existing_hashes(self) -> set[str]:
+        """Get all content hashes currently in the store."""
+        hashes = set()
+        offset = None
+        while True:
+            result = self.client.scroll(
+                collection_name=self.collection_name,
+                limit=100,
+                offset=offset,
+                with_payload=False,
+                with_vectors=False,
+            )
+            points, offset = result
+            for point in points:
+                hashes.add(point.id)
+            if offset is None:
+                break
+        return hashes
+
+    def delete_by_hashes(self, hashes: set[str]):
+        """Delete chunks by their content hashes."""
+        if not hashes:
+            return
+        self.client.delete(
+            collection_name=self.collection_name,
+            points_selector=list(hashes),
+        )
+
+    def count(self) -> int:
+        """Return number of indexed chunks."""
+        return self.client.count(collection_name=self.collection_name).count

fusesearch-0.1.0/fusesearch.egg-info/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: fusesearch
+Version: 0.1.0
+Summary: Multi-source search aggregation tool with AI-powered retrieval and response synthesis
+Author-email: Anton Lebedev <pypi@katzo.net>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.12
+Requires-Dist: qdrant-client>=1.16
+Requires-Dist: fastapi>=0.129
+Requires-Dist: uvicorn>=0.40
+Requires-Dist: tqdm>=4.67
+Provides-Extra: mcp
+Requires-Dist: mcp[cli]>=1.26; extra == "mcp"
+Provides-Extra: local
+Requires-Dist: sentence-transformers>=5.2; extra == "local"
+Provides-Extra: all
+Requires-Dist: fusesearch[local,mcp]; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=9.0; extra == "dev"
+Requires-Dist: ruff>=0.15; extra == "dev"
+Dynamic: license-file
+
+# FuseSearch
+
+Multi-source search aggregation tool that unifies retrieval across diverse data sources — Confluence, MCP servers, local files, and more — using AI-powered search and response synthesis through a single query interface.
+
+## Quick Start
+
+```bash
+make build
+make start
+make index    # index docs from data/docs
+make search "your query"
+```
+
+## MCP Server
+
+The `fusesearch-mcp` Docker service exposes a streamable HTTP endpoint on port 8001. Tools: `search` (hybrid search), `count` (indexed chunks).
+
+### Claude Code
+
+```bash
+claude mcp add fusesearch http://localhost:8001/mcp --transport http
+```
+
+### Claude Desktop
+
+**Option 1: Connectors UI (recommended)**
+
+In Claude Desktop, go to **Settings > Connectors > Add custom connector** and enter `https://localhost:8001/mcp`.
+
+**Option 2: Config file with `mcp-remote` bridge (local dev)**
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "fusesearch": {
+      "command": "npx",
+      "args": ["-y", "mcp-remote", "http://localhost:8001/mcp", "--allow-http"]
+    }
+  }
+}
+```
+
+Requires Node.js >= 18. `--allow-http` is required for plain HTTP (not needed for HTTPS).

fusesearch-0.1.0/fusesearch.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+fusesearch/__init__.py
+fusesearch/__main__.py
+fusesearch/indexer.py
+fusesearch/mcp_server.py
+fusesearch/models.py
+fusesearch.egg-info/PKG-INFO
+fusesearch.egg-info/SOURCES.txt
+fusesearch.egg-info/dependency_links.txt
+fusesearch.egg-info/requires.txt
+fusesearch.egg-info/top_level.txt
+fusesearch/api/__init__.py
+fusesearch/api/server.py
+fusesearch/core/__init__.py
+fusesearch/core/chunker.py
+fusesearch/core/embedder.py
+fusesearch/sources/__init__.py
+fusesearch/sources/base.py
+fusesearch/sources/local_files.py
+fusesearch/store/__init__.py
+fusesearch/store/qdrant.py

fusesearch-0.1.0/fusesearch.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fusesearch-0.1.0/fusesearch.egg-info/requires.txt

@@ -0,0 +1,18 @@
+pydantic>=2.12
+qdrant-client>=1.16
+fastapi>=0.129
+uvicorn>=0.40
+tqdm>=4.67
+
+[all]
+fusesearch[local,mcp]
+
+[dev]
+pytest>=9.0
+ruff>=0.15
+
+[local]
+sentence-transformers>=5.2
+
+[mcp]
+mcp[cli]>=1.26

fusesearch-0.1.0/fusesearch.egg-info/top_level.txt

@@ -0,0 +1 @@
+fusesearch

fusesearch-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "fusesearch"
+version = "0.1.0"
+description = "Multi-source search aggregation tool with AI-powered retrieval and response synthesis"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.12"
+authors = [
+    { name = "Anton Lebedev", email = "pypi@katzo.net" },
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "pydantic>=2.12",
+    "qdrant-client>=1.16",
+    "fastapi>=0.129",
+    "uvicorn>=0.40",
+    "tqdm>=4.67",
+]
+
+[project.optional-dependencies]
+mcp = [
+    "mcp[cli]>=1.26",
+]
+local = [
+    "sentence-transformers>=5.2",
+]
+all = [
+    "fusesearch[mcp,local]",
+]
+dev = [
+    "pytest>=9.0",
+    "ruff>=0.15",
+]

fusesearch-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+