opensolr-mcp 0.1.0__tar.gz

opensolr_mcp-0.1.0/LICENSE

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

opensolr_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: opensolr-mcp
+Version: 0.1.0
+Summary: MCP server for Opensolr — managed Apache Solr with hybrid BM25+kNN search, server-side embeddings, and RAG answers as agent tools
+Author-email: Opensolr <support@opensolr.com>
+License: MIT
+Project-URL: Homepage, https://opensolr.com/langchain
+Project-URL: Repository, https://github.com/phpcip/opensolr-mcp
+Keywords: mcp,model-context-protocol,opensolr,solr,hybrid-search,rag,agents,vector
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.2.0
+Requires-Dist: httpx>=0.25.0
+Dynamic: license-file
+
+# opensolr-mcp
+
+MCP (Model Context Protocol) server for [Opensolr](https://opensolr.com) —
+gives any AI agent **managed Apache Solr search** as tools: hybrid
+(BM25 + kNN) retrieval, server-side GPU embeddings, document indexing, and
+grounded RAG answers.
+
+No embedding model to configure. No vector database to run. One API key.
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `opensolr_search` | Hybrid (keyword + semantic) or pure semantic search, with Solr filters |
+| `opensolr_ai_answer` | Grounded RAG answer generated only from your indexed content |
+| `opensolr_add_documents` | Index plain text + metadata (embedded server-side) |
+| `opensolr_delete_documents` | Remove documents by id |
+| `opensolr_list_indexes` / `opensolr_index_info` | Inspect the account's indexes |
+| `opensolr_create_index` | Provision a vector-enabled index (`us`, `de`, `fi`) |
+| `opensolr_vector_regions` | Live list of vector-enabled regions |
+
+## Setup
+
+Get a free Opensolr account (15-day trial, no card) at
+[opensolr.com/register](https://opensolr.com/register) and copy your API key
+from **Account**.
+
+### Claude Desktop / Claude Code
+
+```json
+{
+  "mcpServers": {
+    "opensolr": {
+      "command": "uvx",
+      "args": ["opensolr-mcp"],
+      "env": {
+        "OPENSOLR_EMAIL": "you@example.com",
+        "OPENSOLR_API_KEY": "YOUR_OPENSOLR_API_KEY"
+      }
+    }
+  }
+}
+```
+
+### Cursor / Windsurf / any MCP client
+
+Same shape — stdio transport, command `uvx opensolr-mcp` (or
+`pipx run opensolr-mcp`), with `OPENSOLR_EMAIL` and `OPENSOLR_API_KEY` in env.
+
+## Example agent session
+
+> **You:** Index our FAQ answers, then find everything about refunds.
+>
+> The agent calls `opensolr_add_documents(index="faq__dense", texts=[...])`,
+> then `opensolr_search(index="faq__dense", query="refund policy", hybrid=True)`
+> — BM25 catches the exact word "refund", kNN catches "giving customers their
+> money back", and the scores fuse per document.
+
+## Notes
+
+- Vector-enabled indexes run on Opensolr's Solr 9.x environments — currently
+  `us` (Chicago), `de` (Germany), `fi` (Finland), fetched live via
+  `opensolr_vector_regions`. Additional dedicated regions can be deployed on
+  request (paid add-on): [support@opensolr.com](mailto:support@opensolr.com).
+- Every index is also plain Apache Solr with the native `/select` API —
+  nothing is locked behind the tools.
+- Python sibling for LangChain: [`langchain-opensolr`](https://pypi.org/project/langchain-opensolr/) ·
+  Product page: [opensolr.com/langchain](https://opensolr.com/langchain)
+
+MIT license.

opensolr_mcp-0.1.0/README.md

@@ -0,0 +1,70 @@
+# opensolr-mcp
+
+MCP (Model Context Protocol) server for [Opensolr](https://opensolr.com) —
+gives any AI agent **managed Apache Solr search** as tools: hybrid
+(BM25 + kNN) retrieval, server-side GPU embeddings, document indexing, and
+grounded RAG answers.
+
+No embedding model to configure. No vector database to run. One API key.
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `opensolr_search` | Hybrid (keyword + semantic) or pure semantic search, with Solr filters |
+| `opensolr_ai_answer` | Grounded RAG answer generated only from your indexed content |
+| `opensolr_add_documents` | Index plain text + metadata (embedded server-side) |
+| `opensolr_delete_documents` | Remove documents by id |
+| `opensolr_list_indexes` / `opensolr_index_info` | Inspect the account's indexes |
+| `opensolr_create_index` | Provision a vector-enabled index (`us`, `de`, `fi`) |
+| `opensolr_vector_regions` | Live list of vector-enabled regions |
+
+## Setup
+
+Get a free Opensolr account (15-day trial, no card) at
+[opensolr.com/register](https://opensolr.com/register) and copy your API key
+from **Account**.
+
+### Claude Desktop / Claude Code
+
+```json
+{
+  "mcpServers": {
+    "opensolr": {
+      "command": "uvx",
+      "args": ["opensolr-mcp"],
+      "env": {
+        "OPENSOLR_EMAIL": "you@example.com",
+        "OPENSOLR_API_KEY": "YOUR_OPENSOLR_API_KEY"
+      }
+    }
+  }
+}
+```
+
+### Cursor / Windsurf / any MCP client
+
+Same shape — stdio transport, command `uvx opensolr-mcp` (or
+`pipx run opensolr-mcp`), with `OPENSOLR_EMAIL` and `OPENSOLR_API_KEY` in env.
+
+## Example agent session
+
+> **You:** Index our FAQ answers, then find everything about refunds.
+>
+> The agent calls `opensolr_add_documents(index="faq__dense", texts=[...])`,
+> then `opensolr_search(index="faq__dense", query="refund policy", hybrid=True)`
+> — BM25 catches the exact word "refund", kNN catches "giving customers their
+> money back", and the scores fuse per document.
+
+## Notes
+
+- Vector-enabled indexes run on Opensolr's Solr 9.x environments — currently
+  `us` (Chicago), `de` (Germany), `fi` (Finland), fetched live via
+  `opensolr_vector_regions`. Additional dedicated regions can be deployed on
+  request (paid add-on): [support@opensolr.com](mailto:support@opensolr.com).
+- Every index is also plain Apache Solr with the native `/select` API —
+  nothing is locked behind the tools.
+- Python sibling for LangChain: [`langchain-opensolr`](https://pypi.org/project/langchain-opensolr/) ·
+  Product page: [opensolr.com/langchain](https://opensolr.com/langchain)
+
+MIT license.

opensolr_mcp-0.1.0/opensolr_mcp/__init__.py

@@ -0,0 +1,5 @@
+"""Opensolr MCP server — hybrid Solr search + RAG as Model Context Protocol tools."""
+
+from opensolr_mcp.client import OpensolrClient, OpensolrError
+
+__all__ = ["OpensolrClient", "OpensolrError"]

opensolr_mcp-0.1.0/opensolr_mcp/client.py

@@ -0,0 +1,243 @@
+"""Thin REST client for the Opensolr platform APIs.
+
+Two base URLs, by platform design:
+- Management API (index list/info/create): https://opensolr.com/solr_manager/api
+- AI API (embed, batch_embed, embed_and_search, ai_summary): https://api.opensolr.com/solr_manager/api
+
+Direct Solr access (select/update) goes to the index's own host, resolved via
+``get_core_info`` (``connection_url`` + HTTP basic auth).
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List, Optional, Tuple
+
+import httpx
+
+MGMT_BASE = "https://opensolr.com/solr_manager/api"
+AI_BASE = "https://api.opensolr.com/solr_manager/api"
+
+#: Convenience aliases for Opensolr's vector-enabled environments. The
+#: authoritative list is served live by the platform (``vector_regions``
+#: endpoint) — new regions become valid automatically, and additional
+#: dedicated regions can be deployed on request (paid): support@opensolr.com.
+VECTOR_LOCATIONS: Dict[str, str] = {
+    "us": "CHICAGO-96",
+    "de": "DE-SOLR-9",
+    "fi": "FINLAND9",
+}
+
+
+def resolve_location(location: str) -> str:
+    """Map a friendly alias ("us"/"de"/"fi") to its environment identifier.
+
+    Unknown values pass through unchanged — validity is decided against the
+    live ``vector_regions`` list (or, ultimately, by the server), so newly
+    deployed vector regions work without a package upgrade.
+    """
+    return VECTOR_LOCATIONS.get(location.strip().lower(), location.strip())
+
+#: Server-side limit for one batch_embed call.
+BATCH_EMBED_MAX = 50
+
+
+class OpensolrError(RuntimeError):
+    """Raised when an Opensolr API call fails."""
+
+
+class OpensolrClient:
+    """Authenticated client for Opensolr management + AI endpoints.
+
+    Args:
+        email: Opensolr account email.
+        api_key: Opensolr API key (Account > API in the control panel).
+        timeout: Per-request timeout in seconds. Embedding calls run on GPU
+            infrastructure and are usually fast, but cold starts happen.
+    """
+
+    def __init__(self, email: str, api_key: str, timeout: float = 120.0) -> None:
+        self.email = email
+        self.api_key = api_key
+        self._http = httpx.Client(timeout=timeout, follow_redirects=True)
+        self._core_info_cache: Dict[str, Dict[str, Any]] = {}
+
+    # ------------------------------------------------------------------ #
+    # low level                                                          #
+    # ------------------------------------------------------------------ #
+
+    def _auth_params(self) -> Dict[str, str]:
+        return {"email": self.email, "api_key": self.api_key}
+
+    def _request(self, base: str, method: str, params: Dict[str, Any]) -> Any:
+        url = f"{base}/{method}"
+        data = {**self._auth_params(), **params}
+        resp = self._http.post(url, data=data)
+        if resp.status_code >= 500:
+            raise OpensolrError(f"{method}: HTTP {resp.status_code}: {resp.text[:200]}")
+        try:
+            body = resp.json()
+        except json.JSONDecodeError as exc:
+            raise OpensolrError(f"{method}: non-JSON response: {resp.text[:200]}") from exc
+        if isinstance(body, dict) and body.get("status") is False:
+            raise OpensolrError(f"{method}: {body.get('msg', body)}")
+        return body
+
+    def mgmt(self, method: str, **params: Any) -> Any:
+        return self._request(MGMT_BASE, method, params)
+
+    def ai(self, method: str, **params: Any) -> Any:
+        return self._request(AI_BASE, method, params)
+
+    # ------------------------------------------------------------------ #
+    # management                                                         #
+    # ------------------------------------------------------------------ #
+
+    def get_index_list(self) -> List[Dict[str, str]]:
+        return self.mgmt("get_index_list")
+
+    def get_core_info(self, index: str, refresh: bool = False) -> Dict[str, Any]:
+        """Resolve an index's Solr endpoint + HTTP auth. Cached per client."""
+        if not refresh and index in self._core_info_cache:
+            return self._core_info_cache[index]
+        body = self.mgmt("get_core_info", core_name=index)
+        msg = body.get("msg") if isinstance(body, dict) else None
+        if not isinstance(msg, dict) or "info" not in msg:
+            raise OpensolrError(f"get_core_info({index}): unexpected response: {str(body)[:200]}")
+        info = msg["info"]
+        self._core_info_cache[index] = info
+        return info
+
+    def vector_regions(self) -> List[Dict[str, str]]:
+        """Live list of vector-enabled environments (Solr 9.x + knn_vector +
+        hybrid parser): ``[{environment, country, solr_version}, ...]``.
+
+        Cached per client. Additional dedicated regions can be deployed on
+        request (paid) — contact support@opensolr.com.
+        """
+        if not hasattr(self, "_vector_regions_cache"):
+            body = self.mgmt("vector_regions")
+            self._vector_regions_cache = body if isinstance(body, list) else []
+        return self._vector_regions_cache
+
+    def create_index(self, index: str, location: str = "us") -> Dict[str, Any]:
+        """Create a vector-enabled index in a vector location.
+
+        ``location`` is an alias ("us", "de", "fi") or a raw Opensolr
+        environment identifier. Validated against the live ``vector_regions``
+        list when reachable; otherwise the server has the final word.
+        """
+        env = resolve_location(location)
+        try:
+            live = {r["environment"] for r in self.vector_regions()}
+        except OpensolrError:
+            live = set(VECTOR_LOCATIONS.values())  # offline fallback
+        if live and env not in live:
+            raise ValueError(
+                f"{location!r} is not a vector-enabled Opensolr location. "
+                f"Currently available: {sorted(live)}. Additional regions can "
+                f"be deployed on request — contact support@opensolr.com."
+            )
+        return self.mgmt(
+            "create_index", index_name=index, core_type="generic", server_country=env
+        )
+
+    # ------------------------------------------------------------------ #
+    # AI                                                                 #
+    # ------------------------------------------------------------------ #
+
+    def embed(self, index: str, text: str, is_query: bool = False) -> List[float]:
+        body = self.ai(
+            "embed", index_name=index, payload=text, is_query="1" if is_query else "0"
+        )
+        if not isinstance(body, list) or not body:
+            raise OpensolrError(f"embed: unexpected response: {str(body)[:200]}")
+        return body
+
+    def batch_embed(self, index: str, texts: List[str]) -> List[List[float]]:
+        """Embed many texts. Chunks transparently at the server's batch limit."""
+        out: List[List[float]] = []
+        for i in range(0, len(texts), BATCH_EMBED_MAX):
+            chunk = texts[i : i + BATCH_EMBED_MAX]
+            resp = self._http.post(
+                f"{AI_BASE}/batch_embed",
+                json={
+                    **self._auth_params(),
+                    "index_name": index,
+                    "payloads": chunk,
+                },
+            )
+            try:
+                body = resp.json()
+            except json.JSONDecodeError as exc:
+                raise OpensolrError(f"batch_embed: non-JSON response: {resp.text[:200]}") from exc
+            if isinstance(body, dict) and body.get("status") is False:
+                raise OpensolrError(f"batch_embed: {body.get('msg', body)}")
+            embeddings = body.get("embeddings") if isinstance(body, dict) else None
+            if not isinstance(embeddings, list) or len(embeddings) != len(chunk):
+                raise OpensolrError(f"batch_embed: unexpected response: {str(body)[:200]}")
+            out.extend(embeddings)
+        return out
+
+    def embed_and_search(self, index: str, query: str, rows: int = 10, **params: Any) -> Dict[str, Any]:
+        """Server-side one-shot: embed the query, run hybrid search, return docs."""
+        body = self.ai(
+            "embed_and_search",
+            index_name=index,
+            q=query,
+            rows=rows,
+            **{"in": "all", "fresh": "no", **params},
+        )
+        return body
+
+    # ------------------------------------------------------------------ #
+    # direct Solr                                                        #
+    # ------------------------------------------------------------------ #
+
+    def solr_endpoint(self, index: str) -> Tuple[str, Optional[Tuple[str, str]]]:
+        """Return (base_url, basic_auth) for the index's native Solr API."""
+        info = self.get_core_info(index)
+        url = info.get("connection_url")
+        if not url:
+            raise OpensolrError(f"No connection_url for index {index!r}")
+        auth = None
+        if info.get("auth_username"):
+            auth = (info["auth_username"], info.get("auth_password") or "")
+        return url, auth
+
+    def solr_select(self, index: str, params: Dict[str, Any]) -> Dict[str, Any]:
+        base, auth = self.solr_endpoint(index)
+        resp = self._http.post(f"{base}/select", data={"wt": "json", **params}, auth=auth)
+        resp.raise_for_status()
+        return resp.json()
+
+    def ai_summary(self, index: str, query: str, **params: Any) -> str:
+        """RAG answer generated from the index's own content. Returns plain text."""
+        resp = self._http.post(
+            f"{AI_BASE}/ai_summary",
+            data={
+                **self._auth_params(),
+                "index_name": index,
+                "query": query,
+                "stream": "false",
+                **params,
+            },
+        )
+        if resp.status_code >= 400:
+            raise OpensolrError(f"ai_summary: HTTP {resp.status_code}: {resp.text[:200]}")
+        return resp.text
+
+    def solr_update(self, index: str, payload: Any, commit: bool = True) -> Dict[str, Any]:
+        base, auth = self.solr_endpoint(index)
+        params = {"commit": "true"} if commit else {"commitWithin": "10000"}
+        resp = self._http.post(
+            f"{base}/update",
+            params=params,
+            json=payload,
+            auth=auth,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def close(self) -> None:
+        self._http.close()

opensolr_mcp-0.1.0/opensolr_mcp/server.py

@@ -0,0 +1,213 @@
+"""Opensolr MCP server — managed Apache Solr with hybrid (BM25 + kNN) search
+and server-side GPU embeddings, exposed as Model Context Protocol tools.
+
+Credentials come from the environment:
+    OPENSOLR_EMAIL    — Opensolr account email
+    OPENSOLR_API_KEY  — Opensolr API key (Account > API in the control panel)
+
+Run: ``opensolr-mcp`` (stdio transport — for Claude Desktop, Cursor, etc.)
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import uuid
+from typing import Any, Dict, List, Optional
+
+from mcp.server import MCPServer
+
+from .client import OpensolrClient, OpensolrError, resolve_location
+
+mcp = MCPServer(
+    "opensolr",
+    instructions=(
+        "Managed Apache Solr search for the user's Opensolr account. "
+        "Use opensolr_search for retrieval (hybrid keyword+semantic by default), "
+        "opensolr_ai_answer for a grounded RAG answer, and the document tools "
+        "to index or remove content. Embedding happens server-side — tools "
+        "accept plain text, never vectors."
+    ),
+)
+
+_client: Optional[OpensolrClient] = None
+
+
+def _get_client() -> OpensolrClient:
+    global _client
+    if _client is None:
+        email = os.environ.get("OPENSOLR_EMAIL", "")
+        api_key = os.environ.get("OPENSOLR_API_KEY", "")
+        if not (email and api_key):
+            raise OpensolrError(
+                "Set OPENSOLR_EMAIL and OPENSOLR_API_KEY in the MCP server "
+                "environment (free account: https://opensolr.com/register)."
+            )
+        _client = OpensolrClient(email, api_key)
+    return _client
+
+
+_META_KEY_RE = re.compile(r"[^a-z0-9_]+")
+
+_HYBRID_MODES = ("union", "keywords_required", "meaning_required", "intersection")
+
+
+def _doc_out(solr_doc: Dict[str, Any]) -> Dict[str, Any]:
+    """Shape a Solr doc for LLM consumption: id, title, text, score, metadata."""
+
+    def _flat(v: Any) -> Any:
+        if isinstance(v, list):
+            return v[0] if len(v) == 1 else v
+        return v
+
+    metadata: Dict[str, Any] = {}
+    raw = _flat(solr_doc.get("meta_lc_json"))
+    if raw:
+        try:
+            metadata = json.loads(raw)
+        except (TypeError, json.JSONDecodeError):
+            metadata = {}
+    text = _flat(solr_doc.get("text", "")) or ""
+    if isinstance(text, list):
+        text = " ".join(str(t) for t in text)
+    return {
+        "id": str(_flat(solr_doc.get("id", ""))),
+        "title": str(_flat(solr_doc.get("title", "")) or "")[:200],
+        "text": str(text)[:2000],
+        "score": float(_flat(solr_doc.get("score", 0.0)) or 0.0),
+        "metadata": metadata,
+    }
+
+
+@mcp.tool()
+def opensolr_search(
+    index: str,
+    query: str,
+    k: int = 5,
+    hybrid: bool = True,
+    mode: str = "union",
+    alpha: float = 0.5,
+    filter_query: Optional[str] = None,
+) -> List[Dict[str, Any]]:
+    """Search an Opensolr index and return the k most relevant documents.
+
+    By default runs HYBRID search: BM25 keyword matching and semantic kNN
+    (server-side embeddings) fused per document. Set hybrid=false for pure
+    semantic search. mode is one of union, keywords_required,
+    meaning_required, intersection; alpha balances semantic (0) vs lexical (1).
+    filter_query accepts a raw Solr fq expression, e.g. 'meta_category:"docs"'.
+    """
+    client = _get_client()
+    vector = client.embed(index, query, is_query=True)
+    compact = json.dumps(vector, separators=(",", ":"))
+    knn = f"{{!knn f=embeddings topK={max(k, 10)}}}{compact}"
+
+    params: Dict[str, Any] = {"rows": k, "fl": "*,score"}
+    if hybrid:
+        if mode not in _HYBRID_MODES:
+            raise ValueError(f"mode must be one of {_HYBRID_MODES}")
+        clean = query.replace("{", " ").replace("}", " ").replace('"', " ")
+        params["q"] = (
+            f"{{!hybrid lexical=$lexicalRaw vector=$vectorQuery "
+            f"mode={mode} alpha={alpha} topN={max(k, 10)}}}"
+        )
+        params["lexicalRaw"] = f'{{!edismax qf="title^100 text^1"}}{clean}'
+        params["vectorQuery"] = knn
+    else:
+        params["q"] = knn
+    if filter_query:
+        params["fq"] = filter_query
+
+    body = client.solr_select(index, params)
+    return [_doc_out(d) for d in body["response"]["docs"]]
+
+
+@mcp.tool()
+def opensolr_ai_answer(index: str, query: str) -> str:
+    """Ask a question and get a grounded RAG answer generated ONLY from the
+    content already indexed in the given Opensolr index (retrieval + LLM,
+    all server-side)."""
+    return _get_client().ai_summary(index, query)
+
+
+@mcp.tool()
+def opensolr_list_indexes() -> List[Dict[str, str]]:
+    """List all search indexes in the connected Opensolr account."""
+    return _get_client().get_index_list()
+
+
+@mcp.tool()
+def opensolr_index_info(index: str) -> Dict[str, Any]:
+    """Get connection details for an index: Solr URL, version, environment.
+    (Credentials are intentionally not returned.)"""
+    info = _get_client().get_core_info(index)
+    return {
+        "connection_url": info.get("connection_url"),
+        "solr_version": info.get("solr_version"),
+        "environment": info.get("environment_identifier"),
+        "type": info.get("type"),
+    }
+
+
+@mcp.tool()
+def opensolr_add_documents(
+    index: str,
+    texts: List[str],
+    metadatas: Optional[List[Dict[str, Any]]] = None,
+    ids: Optional[List[str]] = None,
+) -> List[str]:
+    """Index plain-text documents with optional metadata dicts. Embeddings are
+    computed server-side automatically. Returns the document ids."""
+    client = _get_client()
+    metadatas = metadatas or [{} for _ in texts]
+    ids = ids or [str(uuid.uuid4()) for _ in texts]
+    if not (len(texts) == len(metadatas) == len(ids)):
+        raise ValueError("texts, metadatas and ids must have the same length")
+
+    vectors = client.batch_embed(index, texts)
+    docs = []
+    for text, meta, doc_id, vector in zip(texts, metadatas, ids, vectors):
+        doc: Dict[str, Any] = {
+            "id": doc_id,
+            "text": text,
+            "embeddings": vector,
+            "meta_lc_json": json.dumps(meta, ensure_ascii=False),
+            "title": str(meta.get("title") or text[:100]),
+        }
+        for key, value in (meta or {}).items():
+            if isinstance(value, (str, int, float, bool)):
+                doc[f"meta_{_META_KEY_RE.sub('_', str(key).lower()).strip('_')}"] = str(value)
+        docs.append(doc)
+    client.solr_update(index, docs)
+    return ids
+
+
+@mcp.tool()
+def opensolr_delete_documents(index: str, ids: List[str]) -> str:
+    """Delete documents from an index by their ids."""
+    _get_client().solr_update(index, {"delete": list(ids)})
+    return f"deleted {len(ids)} document(s)"
+
+
+@mcp.tool()
+def opensolr_create_index(index: str, location: str = "us") -> Dict[str, Any]:
+    """Create a new vector-enabled Opensolr index. location: us, de, fi, or
+    any environment id from opensolr_vector_regions. Additional dedicated
+    regions can be deployed on request (support@opensolr.com)."""
+    return _get_client().create_index(index, resolve_location(location))
+
+
+@mcp.tool()
+def opensolr_vector_regions() -> List[Dict[str, str]]:
+    """List the vector-enabled Opensolr environments currently available
+    (Solr 9.x with dense vectors and the hybrid query parser)."""
+    return _get_client().vector_regions()
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: opensolr-mcp
+Version: 0.1.0
+Summary: MCP server for Opensolr — managed Apache Solr with hybrid BM25+kNN search, server-side embeddings, and RAG answers as agent tools
+Author-email: Opensolr <support@opensolr.com>
+License: MIT
+Project-URL: Homepage, https://opensolr.com/langchain
+Project-URL: Repository, https://github.com/phpcip/opensolr-mcp
+Keywords: mcp,model-context-protocol,opensolr,solr,hybrid-search,rag,agents,vector
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.2.0
+Requires-Dist: httpx>=0.25.0
+Dynamic: license-file
+
+# opensolr-mcp
+
+MCP (Model Context Protocol) server for [Opensolr](https://opensolr.com) —
+gives any AI agent **managed Apache Solr search** as tools: hybrid
+(BM25 + kNN) retrieval, server-side GPU embeddings, document indexing, and
+grounded RAG answers.
+
+No embedding model to configure. No vector database to run. One API key.
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `opensolr_search` | Hybrid (keyword + semantic) or pure semantic search, with Solr filters |
+| `opensolr_ai_answer` | Grounded RAG answer generated only from your indexed content |
+| `opensolr_add_documents` | Index plain text + metadata (embedded server-side) |
+| `opensolr_delete_documents` | Remove documents by id |
+| `opensolr_list_indexes` / `opensolr_index_info` | Inspect the account's indexes |
+| `opensolr_create_index` | Provision a vector-enabled index (`us`, `de`, `fi`) |
+| `opensolr_vector_regions` | Live list of vector-enabled regions |
+
+## Setup
+
+Get a free Opensolr account (15-day trial, no card) at
+[opensolr.com/register](https://opensolr.com/register) and copy your API key
+from **Account**.
+
+### Claude Desktop / Claude Code
+
+```json
+{
+  "mcpServers": {
+    "opensolr": {
+      "command": "uvx",
+      "args": ["opensolr-mcp"],
+      "env": {
+        "OPENSOLR_EMAIL": "you@example.com",
+        "OPENSOLR_API_KEY": "YOUR_OPENSOLR_API_KEY"
+      }
+    }
+  }
+}
+```
+
+### Cursor / Windsurf / any MCP client
+
+Same shape — stdio transport, command `uvx opensolr-mcp` (or
+`pipx run opensolr-mcp`), with `OPENSOLR_EMAIL` and `OPENSOLR_API_KEY` in env.
+
+## Example agent session
+
+> **You:** Index our FAQ answers, then find everything about refunds.
+>
+> The agent calls `opensolr_add_documents(index="faq__dense", texts=[...])`,
+> then `opensolr_search(index="faq__dense", query="refund policy", hybrid=True)`
+> — BM25 catches the exact word "refund", kNN catches "giving customers their
+> money back", and the scores fuse per document.
+
+## Notes
+
+- Vector-enabled indexes run on Opensolr's Solr 9.x environments — currently
+  `us` (Chicago), `de` (Germany), `fi` (Finland), fetched live via
+  `opensolr_vector_regions`. Additional dedicated regions can be deployed on
+  request (paid add-on): [support@opensolr.com](mailto:support@opensolr.com).
+- Every index is also plain Apache Solr with the native `/select` API —
+  nothing is locked behind the tools.
+- Python sibling for LangChain: [`langchain-opensolr`](https://pypi.org/project/langchain-opensolr/) ·
+  Product page: [opensolr.com/langchain](https://opensolr.com/langchain)
+
+MIT license.

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

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+opensolr_mcp/__init__.py
+opensolr_mcp/client.py
+opensolr_mcp/server.py
+opensolr_mcp.egg-info/PKG-INFO
+opensolr_mcp.egg-info/SOURCES.txt
+opensolr_mcp.egg-info/dependency_links.txt
+opensolr_mcp.egg-info/entry_points.txt
+opensolr_mcp.egg-info/requires.txt
+opensolr_mcp.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

opensolr_mcp-0.1.0/opensolr_mcp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+opensolr-mcp = opensolr_mcp.server:main

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

@@ -0,0 +1,2 @@
+mcp>=1.2.0
+httpx>=0.25.0

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

@@ -0,0 +1 @@
+opensolr_mcp

opensolr_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "opensolr-mcp"
+version = "0.1.0"
+description = "MCP server for Opensolr — managed Apache Solr with hybrid BM25+kNN search, server-side embeddings, and RAG answers as agent tools"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [{ name = "Opensolr", email = "support@opensolr.com" }]
+dependencies = [
+    "mcp>=1.2.0",
+    "httpx>=0.25.0",
+]
+keywords = ["mcp", "model-context-protocol", "opensolr", "solr", "hybrid-search", "rag", "agents", "vector"]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+]
+
+[project.urls]
+Homepage = "https://opensolr.com/langchain"
+Repository = "https://github.com/phpcip/opensolr-mcp"
+
+[project.scripts]
+opensolr-mcp = "opensolr_mcp.server:main"
+
+[tool.setuptools]
+packages = ["opensolr_mcp"]

opensolr_mcp-0.1.0/setup.cfg

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