dify-mcp 0.1.0__py3-none-any.whl

dify_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""Dify Knowledge Base MCP Server."""
+
+__version__ = "0.1.0"

dify_mcp/config.py

@@ -0,0 +1,64 @@
+from pathlib import Path
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+def _find_env_file() -> str | None:
+    """Locate an optional .env file.
+
+    Environment variables always take precedence; a .env file is only a
+    convenience fallback. We look in the current working directory first
+    (normal usage), then in the source-checkout project root. When the
+    package is pip-installed and no local .env exists, this returns None and
+    configuration comes entirely from the process environment (e.g. the
+    ``env`` block of an MCP client's ``mcp.json``).
+    """
+    candidates = [
+        Path.cwd() / ".env",
+        Path(__file__).resolve().parents[2] / ".env",
+    ]
+    for path in candidates:
+        if path.is_file():
+            return str(path)
+    return None
+
+
+ENV_FILE = _find_env_file()
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_file=ENV_FILE,
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+    dify_api_base: str = "http://127.0.0.1/v1"
+    dify_api_key: str
+    dify_allowed_datasets: str
+    dify_timeout: float = 30.0
+    dify_verify_ssl: bool = False
+
+    @property
+    def api_base(self) -> str:
+        base = self.dify_api_base.rstrip("/")
+        if not base.startswith(("http://", "https://")):
+            base = f"http://{base}"
+        return base
+
+    @property
+    def allowed_dataset_ids(self) -> frozenset[str]:
+        ids = {item.strip() for item in self.dify_allowed_datasets.split(",") if item.strip()}
+        if not ids:
+            raise ValueError("DIFY_ALLOWED_DATASETS must contain at least one dataset UUID")
+        return frozenset(ids)
+
+    def ensure_dataset_allowed(self, dataset_id: str) -> None:
+        if dataset_id not in self.allowed_dataset_ids:
+            allowed = ", ".join(sorted(self.allowed_dataset_ids))
+            raise PermissionError(
+                f"Dataset '{dataset_id}' is not in the allowed list: {allowed}"
+            )
+
+
+def load_settings() -> Settings:
+    return Settings()  # type: ignore[call-arg]

dify_mcp/dify_client.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from dify_mcp.config import Settings
+
+
+class DifyAPIError(Exception):
+    def __init__(self, message: str, status_code: int | None = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class DifyClient:
+    def __init__(self, settings: Settings) -> None:
+        self._settings = settings
+        self._client = httpx.AsyncClient(
+            base_url=settings.api_base,
+            headers={
+                "Authorization": f"Bearer {settings.dify_api_key}",
+                "Content-Type": "application/json",
+            },
+            timeout=settings.dify_timeout,
+            verify=settings.dify_verify_ssl,
+        )
+
+    async def close(self) -> None:
+        await self._client.aclose()
+
+    async def _request(self, method: str, path: str, **kwargs: Any) -> Any:
+        try:
+            response = await self._client.request(method, path, **kwargs)
+        except httpx.TimeoutException as exc:
+            raise DifyAPIError(
+                f"Request timed out after {self._settings.dify_timeout}s: {method} {path}"
+            ) from exc
+        except httpx.RequestError as exc:
+            raise DifyAPIError(f"Network error calling Dify API: {exc}") from exc
+
+        if response.status_code >= 400:
+            detail = response.text.strip() or response.reason_phrase
+            raise DifyAPIError(
+                f"Dify API error {response.status_code}: {detail}",
+                status_code=response.status_code,
+            )
+
+        if response.status_code == 204 or not response.content:
+            return {}
+        return response.json()
+
+    async def health_check(self) -> dict[str, Any]:
+        return await self.list_datasets(page=1, limit=1)
+
+    async def list_datasets(
+        self,
+        *,
+        page: int = 1,
+        limit: int = 20,
+        keyword: str | None = None,
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {"page": page, "limit": limit}
+        if keyword:
+            params["keyword"] = keyword
+        return await self._request("GET", "/datasets", params=params)
+
+    async def get_dataset(self, dataset_id: str) -> dict[str, Any]:
+        return await self._request("GET", f"/datasets/{dataset_id}")
+
+    async def retrieve(
+        self,
+        dataset_id: str,
+        query: str,
+        *,
+        top_k: int = 5,
+        search_method: str | None = None,
+        reranking_enable: bool | None = None,
+        score_threshold_enabled: bool | None = None,
+        score_threshold: float | None = None,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {"query": query}
+        retrieval_model: dict[str, Any] = {"top_k": top_k}
+
+        if search_method is not None:
+            retrieval_model["search_method"] = search_method
+        if reranking_enable is not None:
+            retrieval_model["reranking_enable"] = reranking_enable
+        if score_threshold_enabled is not None:
+            retrieval_model["score_threshold_enabled"] = score_threshold_enabled
+        if score_threshold is not None:
+            retrieval_model["score_threshold"] = score_threshold
+
+        if len(retrieval_model) > 1 or "top_k" in retrieval_model:
+            body["retrieval_model"] = retrieval_model
+
+        return await self._request("POST", f"/datasets/{dataset_id}/retrieve", json=body)
+
+    async def list_documents(
+        self,
+        dataset_id: str,
+        *,
+        page: int = 1,
+        limit: int = 20,
+        keyword: str | None = None,
+        status: str | None = None,
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {"page": page, "limit": limit}
+        if keyword:
+            params["keyword"] = keyword
+        if status:
+            params["status"] = status
+        return await self._request("GET", f"/datasets/{dataset_id}/documents", params=params)
+
+    async def get_document(self, dataset_id: str, document_id: str) -> dict[str, Any]:
+        return await self._request("GET", f"/datasets/{dataset_id}/documents/{document_id}")
+
+    async def list_segments(
+        self,
+        dataset_id: str,
+        document_id: str,
+        *,
+        page: int = 1,
+        limit: int = 20,
+        keyword: str | None = None,
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {"page": page, "limit": limit}
+        if keyword:
+            params["keyword"] = keyword
+        return await self._request(
+            "GET",
+            f"/datasets/{dataset_id}/documents/{document_id}/segments",
+            params=params,
+        )

dify_mcp/formatters.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def simplify_dataset(item: dict[str, Any]) -> dict[str, Any]:
+    retrieval = item.get("retrieval_model_dict") or {}
+    return {
+        "id": item.get("id"),
+        "name": item.get("name"),
+        "description": item.get("description"),
+        "document_count": item.get("document_count"),
+        "indexing_technique": item.get("indexing_technique"),
+        "search_method": retrieval.get("search_method"),
+        "top_k": retrieval.get("top_k"),
+        "enable_api": item.get("enable_api"),
+    }
+
+
+def simplify_document(item: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "id": item.get("id"),
+        "name": item.get("name"),
+        "indexing_status": item.get("indexing_status"),
+        "word_count": item.get("word_count"),
+        "hit_count": item.get("hit_count"),
+        "created_at": item.get("created_at"),
+    }
+
+
+def format_retrieve_results(payload: dict[str, Any], dataset_id: str) -> dict[str, Any]:
+    query_obj = payload.get("query") or {}
+    query_text = query_obj.get("content") if isinstance(query_obj, dict) else query_obj
+
+    results: list[dict[str, Any]] = []
+    for record in payload.get("records") or []:
+        segment = record.get("segment") or {}
+        document = segment.get("document") or {}
+        results.append(
+            {
+                "content": segment.get("content", ""),
+                "answer": segment.get("answer") or None,
+                "score": record.get("score"),
+                "segment_id": segment.get("id"),
+                "document_id": segment.get("document_id") or document.get("id"),
+                "document_name": document.get("name"),
+                "position": segment.get("position"),
+            }
+        )
+
+    return {
+        "dataset_id": dataset_id,
+        "query": query_text,
+        "result_count": len(results),
+        "results": results,
+    }

dify_mcp/server.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import json
+from contextlib import asynccontextmanager
+from typing import Any, AsyncIterator
+
+from mcp.server.fastmcp import Context, FastMCP
+
+from dify_mcp.config import Settings, load_settings
+from dify_mcp.dify_client import DifyAPIError, DifyClient
+from dify_mcp.formatters import format_retrieve_results, simplify_dataset, simplify_document
+
+MAX_QUERY_LENGTH = 250
+
+
+def _error(message: str) -> str:
+    return json.dumps({"error": message}, ensure_ascii=False)
+
+
+def _ok(payload: Any) -> str:
+    return json.dumps(payload, ensure_ascii=False, indent=2)
+
+
+@asynccontextmanager
+async def app_lifespan(server: FastMCP) -> AsyncIterator[dict[str, Any]]:
+    settings = load_settings()
+    client = DifyClient(settings)
+    try:
+        await client.health_check()
+    except DifyAPIError as exc:
+        raise RuntimeError(f"Dify connectivity check failed: {exc}") from exc
+
+    yield {"settings": settings, "client": client}
+    await client.close()
+
+
+mcp = FastMCP(
+    "dify-knowledge",
+    instructions=(
+        "Tools for querying Dify knowledge bases over the LAN. "
+        "Only datasets listed in DIFY_ALLOWED_DATASETS are accessible. "
+        "Use list_datasets to discover allowed knowledge bases, then search_knowledge to retrieve chunks."
+    ),
+    lifespan=app_lifespan,
+)
+
+
+def _ctx(ctx: Context) -> tuple[Settings, DifyClient]:
+    settings: Settings = ctx.request_context.lifespan_context["settings"]
+    client: DifyClient = ctx.request_context.lifespan_context["client"]
+    return settings, client
+
+
+@mcp.tool()
+async def list_datasets(
+    ctx: Context,
+    keyword: str | None = None,
+    page: int = 1,
+    limit: int = 20,
+) -> str:
+    """List allowed Dify knowledge bases (filtered by DIFY_ALLOWED_DATASETS)."""
+    settings, client = _ctx(ctx)
+    try:
+        payload = await client.list_datasets(page=page, limit=limit, keyword=keyword)
+    except DifyAPIError as exc:
+        return _error(str(exc))
+
+    datasets = [
+        simplify_dataset(item)
+        for item in payload.get("data") or []
+        if item.get("id") in settings.allowed_dataset_ids
+    ]
+    return _ok(
+        {
+            "allowed_dataset_ids": sorted(settings.allowed_dataset_ids),
+            "datasets": datasets,
+            "total": len(datasets),
+            "has_more": payload.get("has_more", False),
+        }
+    )
+
+
+@mcp.tool()
+async def get_dataset(ctx: Context, dataset_id: str) -> str:
+    """Get details for one allowed knowledge base."""
+    settings, client = _ctx(ctx)
+    try:
+        settings.ensure_dataset_allowed(dataset_id)
+        payload = await client.get_dataset(dataset_id)
+    except PermissionError as exc:
+        return _error(str(exc))
+    except DifyAPIError as exc:
+        return _error(str(exc))
+
+    return _ok(simplify_dataset(payload))
+
+
+@mcp.tool()
+async def search_knowledge(
+    ctx: Context,
+    dataset_id: str,
+    query: str,
+    top_k: int = 5,
+    search_method: str | None = None,
+) -> str:
+    """Retrieve relevant chunks from an allowed Dify knowledge base."""
+    settings, client = _ctx(ctx)
+    query = query.strip()
+    if not query:
+        return _error("query must not be empty")
+    if len(query) > MAX_QUERY_LENGTH:
+        return _error(f"query exceeds Dify limit of {MAX_QUERY_LENGTH} characters")
+
+    try:
+        settings.ensure_dataset_allowed(dataset_id)
+        payload = await client.retrieve(
+            dataset_id,
+            query,
+            top_k=top_k,
+            search_method=search_method,
+        )
+    except PermissionError as exc:
+        return _error(str(exc))
+    except DifyAPIError as exc:
+        return _error(str(exc))
+
+    return _ok(format_retrieve_results(payload, dataset_id))
+
+
+@mcp.tool()
+async def list_documents(
+    ctx: Context,
+    dataset_id: str,
+    keyword: str | None = None,
+    page: int = 1,
+    limit: int = 20,
+    status: str | None = None,
+) -> str:
+    """List documents inside an allowed knowledge base."""
+    settings, client = _ctx(ctx)
+    try:
+        settings.ensure_dataset_allowed(dataset_id)
+        payload = await client.list_documents(
+            dataset_id,
+            page=page,
+            limit=limit,
+            keyword=keyword,
+            status=status,
+        )
+    except PermissionError as exc:
+        return _error(str(exc))
+    except DifyAPIError as exc:
+        return _error(str(exc))
+
+    documents = [simplify_document(item) for item in payload.get("data") or []]
+    return _ok(
+        {
+            "dataset_id": dataset_id,
+            "documents": documents,
+            "total": payload.get("total"),
+            "has_more": payload.get("has_more", False),
+        }
+    )
+
+
+@mcp.tool()
+async def list_document_segments(
+    ctx: Context,
+    dataset_id: str,
+    document_id: str,
+    keyword: str | None = None,
+    page: int = 1,
+    limit: int = 20,
+) -> str:
+    """List text segments (chunks) for a document in an allowed knowledge base."""
+    settings, client = _ctx(ctx)
+    try:
+        settings.ensure_dataset_allowed(dataset_id)
+        payload = await client.list_segments(
+            dataset_id,
+            document_id,
+            page=page,
+            limit=limit,
+            keyword=keyword,
+        )
+    except PermissionError as exc:
+        return _error(str(exc))
+    except DifyAPIError as exc:
+        return _error(str(exc))
+
+    segments = [
+        {
+            "id": item.get("id"),
+            "content": item.get("content"),
+            "position": item.get("position"),
+            "word_count": item.get("word_count"),
+            "enabled": item.get("enabled"),
+        }
+        for item in payload.get("data") or []
+    ]
+    return _ok(
+        {
+            "dataset_id": dataset_id,
+            "document_id": document_id,
+            "segments": segments,
+            "total": payload.get("total"),
+            "has_more": payload.get("has_more", False),
+        }
+    )
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

dify_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,231 @@
+Metadata-Version: 2.4
+Name: dify-mcp
+Version: 0.1.0
+Summary: MCP server exposing Dify knowledge base retrieval to Cursor and other MCP clients
+Project-URL: Homepage, https://github.com/salted-butter-joshua/dify-mcp
+Project-URL: Repository, https://github.com/salted-butter-joshua/dify-mcp
+Project-URL: Issues, https://github.com/salted-butter-joshua/dify-mcp/issues
+Author-email: salted-butter-joshua <chenshidatou@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: dify,knowledge-base,llm,mcp,model-context-protocol,rag,retrieval
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mcp>=1.6.0
+Requires-Dist: pydantic-settings>=2.0.0
+Description-Content-Type: text/markdown
+
+# dify-mcp
+
+<!-- mcp-name: io.github.salted-butter-joshua/dify-mcp -->
+
+Expose [Dify](https://dify.ai) knowledge base retrieval capabilities via [MCP](https://modelcontextprotocol.io) (Model Context Protocol), for use in Cursor and other MCP-compatible clients.
+
+Connect to a self-hosted or remote Dify instance over HTTP, with optional dataset allowlisting for access control.
+
+## Features
+
+- **Knowledge base discovery** — list and inspect allowed datasets
+- **Semantic retrieval** — search chunks via Dify `POST /datasets/{dataset_id}/retrieve`
+- **Document browsing** — list documents and segments within a dataset
+- **Dataset allowlist** — restrict access to specific `dataset_id` values
+- **stdio transport** — no manual server startup; the MCP client launches the process
+
+## Requirements
+
+- Python **3.11+**
+- A running Dify instance with Knowledge Base API enabled
+- Network access from the machine running the MCP server to your Dify API endpoint
+- A Dify **Knowledge Base API Key** (Dify → Knowledge → Service API → API Key)
+
+## Quick Start
+
+### 1. Clone and install
+
+```bash
+git clone https://github.com/salted-butter-joshua/dify-mcp.git
+cd dify-mcp
+
+python3.11 -m venv .venv
+
+# Windows
+.venv\Scripts\python.exe -m pip install -e .
+
+# macOS / Linux
+.venv/bin/python -m pip install -e .
+```
+
+Verify import:
+
+```bash
+# Windows
+.venv\Scripts\python.exe -c "import dify_mcp; print('OK')"
+
+# macOS / Linux
+.venv/bin/python -c "import dify_mcp; print('OK')"
+```
+
+### 2. Configure environment
+
+Copy the example env file and edit it:
+
+```bash
+cp .env.example .env
+```
+
+```env
+DIFY_API_BASE=http://your-dify-host/v1
+DIFY_API_KEY=dataset-your-api-key
+DIFY_ALLOWED_DATASETS=dataset-uuid-1,dataset-uuid-2
+DIFY_TIMEOUT=30
+DIFY_VERIFY_SSL=false
+```
+
+| Variable | Description |
+|----------|-------------|
+| `DIFY_API_BASE` | Dify Knowledge API base URL, e.g. `http://192.168.1.100/v1` |
+| `DIFY_API_KEY` | Knowledge Base API key |
+| `DIFY_ALLOWED_DATASETS` | Comma-separated dataset UUIDs to expose (required) |
+| `DIFY_TIMEOUT` | HTTP timeout in seconds (default: `30`) |
+| `DIFY_VERIFY_SSL` | Verify TLS certificates (default: `false` for self-signed certs) |
+
+Run the health check:
+
+```bash
+# Windows
+.venv\Scripts\python.exe scripts/health_check.py
+
+# macOS / Linux
+.venv/bin/python scripts/health_check.py
+```
+
+### 3. Add to Cursor
+
+You do **not** need to start the MCP server manually. Cursor launches it automatically via stdio.
+
+1. Open Cursor Settings → **MCP** → **Edit config**
+2. Add the following to `mcpServers` in your MCP config file:
+   - Windows: `%USERPROFILE%\.cursor\mcp.json`
+   - macOS / Linux: `~/.cursor/mcp.json`
+3. Replace paths and env values with your own
+4. Restart Cursor
+
+See [`mcp.json.example`](mcp.json.example) for a full example.
+
+**Windows example:**
+
+```json
+{
+  "mcpServers": {
+    "dify-knowledge": {
+      "command": "/absolute/path/to/dify-mcp/.venv/Scripts/python.exe",
+      "args": ["-m", "dify_mcp.server"],
+      "cwd": "/absolute/path/to/dify-mcp",
+      "env": {
+        "DIFY_API_BASE": "http://your-dify-host/v1",
+        "DIFY_API_KEY": "dataset-your-api-key",
+        "DIFY_ALLOWED_DATASETS": "dataset-uuid-1,dataset-uuid-2",
+        "DIFY_TIMEOUT": "30",
+        "DIFY_VERIFY_SSL": "false"
+      }
+    }
+  }
+}
+```
+
+**macOS / Linux example:**
+
+```json
+{
+  "mcpServers": {
+    "dify-knowledge": {
+      "command": "/absolute/path/to/dify-mcp/.venv/bin/python",
+      "args": ["-m", "dify_mcp.server"],
+      "cwd": "/absolute/path/to/dify-mcp",
+      "env": {
+        "DIFY_API_BASE": "http://your-dify-host/v1",
+        "DIFY_API_KEY": "dataset-your-api-key",
+        "DIFY_ALLOWED_DATASETS": "dataset-uuid-1,dataset-uuid-2"
+      }
+    }
+  }
+}
+```
+
+### 4. Verify in Cursor
+
+1. Cursor Settings → **MCP** → confirm `dify-knowledge` shows as enabled
+2. In chat, try:
+   - *List available Dify knowledge bases*
+   - *Search the knowledge base for "your query"*
+
+## MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `list_datasets` | List knowledge bases within the allowlist |
+| `get_dataset` | Get metadata for one dataset |
+| `search_knowledge` | Retrieve relevant chunks (primary retrieval tool) |
+| `list_documents` | List documents in a dataset |
+| `list_document_segments` | List text segments for a document |
+
+## Architecture
+
+```
+Cursor (MCP client)
+    │ stdio
+    ▼
+dify-mcp (local process)
+    │ HTTPS / HTTP
+    ▼
+Dify Knowledge API (/v1/datasets/...)
+```
+
+The MCP server runs locally on your machine and calls the Dify API over the network. Dify does not need to reach your machine.
+
+## Troubleshooting
+
+| Issue | Cause | Fix |
+|-------|-------|-----|
+| `No matching distribution found for mcp` | Python < 3.11 | Use Python 3.11+ in `.venv` |
+| MCP shows error (red) | Wrong Python path, invalid key, or network issue | Check `mcp.json` paths and env vars |
+| `401 Unauthorized` | Invalid API key | Regenerate key in Dify Service API panel |
+| `Dataset not in allowed list` | UUID not in `DIFY_ALLOWED_DATASETS` | Add the dataset UUID to the allowlist |
+| Health check missing env vars | `.env` not found | Ensure `.env` exists in the project root |
+| Connection timeout | Dify unreachable | Check network / VPN / firewall |
+
+## Project Structure
+
+```
+dify-mcp/
+├── src/dify_mcp/
+│   ├── server.py        # MCP entry point
+│   ├── config.py        # Settings and allowlist
+│   ├── dify_client.py   # Dify Knowledge API client
+│   └── formatters.py    # Response formatting
+├── scripts/
+│   └── health_check.py  # Connectivity test
+├── mcp.json.example     # Cursor MCP config template
+├── .env.example         # Environment variable template
+└── Dify-API.md          # Local API path reference
+```
+
+## API Reference
+
+- [Dify Knowledge Base API (official)](https://docs.dify.ai/api-reference/knowledge-bases/list-knowledge-bases)
+- [Retrieve chunks](https://docs.dify.ai/api-reference/knowledge-bases/retrieve-chunks-from-a-knowledge-base-test-retrieval)
+- Local path reference: [`Dify-API.md`](Dify-API.md)
+
+## Security Notes
+
+- Never commit `.env` or API keys to version control
+- A single Knowledge Base API key can access all visible datasets under the account — use `DIFY_ALLOWED_DATASETS` to limit exposure
+- Prefer running MCP locally; keep API keys in `mcp.json` env or `.env` on your machine only

dify_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+dify_mcp/__init__.py,sha256=ctxkdpmhSdHV-NDl-ItAQkReUiY5hkWbXtjaAXBXPoA,64
+dify_mcp/config.py,sha256=VHThs8k-uUOX3lxmjowTBjU9oDMaafWtAtBPd7a0g-o,2128
+dify_mcp/dify_client.py,sha256=H6lq_KZEL8R6T39bIZsVrFWbEudM4id-1ks-AxSjdSE,4699
+dify_mcp/formatters.py,sha256=bw-4ugvBpP6V_ZK23_s33NItNtvG3ZxbLfFA_wuYYHE,1977
+dify_mcp/server.py,sha256=1P6FbmeTs2_PwkmaVvb3bTxyACnME4wEQhZD_wYN1ns,6216
+dify_mcp-0.1.0.dist-info/METADATA,sha256=YFfpmwaXr015LhlizFd_COHv1ZnuHB1KIArYV7_D3wc,7495
+dify_mcp-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+dify_mcp-0.1.0.dist-info/entry_points.txt,sha256=Sfbz8BEZk-jsHdF8IXTXWDKkFlEATlO7b7Yi2wscHwU,50
+dify_mcp-0.1.0.dist-info/licenses/LICENSE,sha256=34DTZXciXb86yKtzo8a0njblbt6nm7wJeGkYg4qUk04,1077
+dify_mcp-0.1.0.dist-info/RECORD,,

dify_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

dify_mcp-0.1.0.dist-info/entry_points.txt

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

dify_mcp-0.1.0.dist-info/licenses/LICENSE

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