websift 0.1.0__py3-none-any.whl

web_search/__init__.py

@@ -0,0 +1,16 @@
+"""
+web_search - Self-contained web search & page fetch utility.
+
+Usage:
+    from web_search import WebSearchClient
+
+    client = WebSearchClient()
+    client.search("python asyncio tutorial")
+    client.fetch("https://docs.python.org/3/library/asyncio.html")
+"""
+
+__version__ = "0.1.0"
+
+from web_search.client import WebSearchClient
+
+__all__ = ["WebSearchClient", "__version__"]

web_search/client.py

@@ -0,0 +1,102 @@
+"""WebSearchClient: search and fetch with SSRF protection."""
+
+import re
+from typing import Optional
+from urllib.parse import urlparse
+
+from web_search.config import MAX_FETCH_BYTES, MAX_PAGE_CHARS, MAX_PDF_FETCH_BYTES
+from web_search.content import looks_like_html, looks_like_html_document
+from web_search.html import html_to_markdown, truncate
+from web_search.http import fetch_raw
+
+_GITHUB_NAME_RE = re.compile(r"^[A-Za-z0-9_.-]+$")
+_GITHUB_NON_OWNER_SEGMENTS = {
+    "features", "pricing", "about", "contact", "login", "signup",
+    "topics", "trending", "explore", "marketplace", "settings",
+    "notifications", "issues", "pulls", "discussions",
+}
+
+
+class WebSearchClient:
+    """
+    Self-contained web search + page fetch.
+    No API key required. Uses DuckDuckGo (ddgs) for search,
+    urllib for fetch, with SSRF protection + DNS pinning.
+    """
+
+    def __init__(
+        self,
+        max_results: int = 5,
+        timeout: int = 30,
+        max_page_chars: int = MAX_PAGE_CHARS,
+    ):
+        self.max_results = max_results
+        self.timeout = timeout
+        self.max_page_chars = max_page_chars
+
+    def search(self, query: str) -> str:
+        if not query or not query.strip():
+            return "No query provided."
+        try:
+            from ddgs import DDGS
+        except ImportError:
+            return "Error: ddgs not installed. Run: pip install ddgs"
+        try:
+            results = DDGS(timeout=self.timeout).text(query.strip(), max_results=self.max_results)
+        except Exception as e:
+            return f"Search failed: {e}"
+        if not results:
+            return "No results found."
+        parts = [
+            f"Title: {r.get('title', '')}\nURL: {r.get('href', '')}\nSnippet: {r.get('body', '')}"
+            for r in results
+        ]
+        return "\n\n---\n\n".join(parts) + (
+            "\n\n---\n\nIMPORTANT: These are short snippets only. "
+            "Call fetch(url) with a specific URL to get full page content."
+        )
+
+    def fetch(self, url: str) -> str:
+        url = url.strip()
+        if not url:
+            return "No URL provided."
+
+        readme_url = self._github_readme_api_url(url)
+        if readme_url:
+            err, body, _ = fetch_raw(
+                readme_url, self.timeout, MAX_FETCH_BYTES, MAX_PDF_FETCH_BYTES,
+                extra_headers={
+                    "Accept": "application/vnd.github.raw+json",
+                    "X-GitHub-Api-Version": "2022-11-28",
+                },
+            )
+            if err is None and body.strip():
+                content = html_to_markdown(body, main_content=True) if looks_like_html_document(body) else body
+                if content.strip():
+                    return truncate(f"README of {url} (via GitHub API):\n\n{content}", self.max_page_chars)
+
+        err, body, content_type = fetch_raw(url, self.timeout, MAX_FETCH_BYTES, MAX_PDF_FETCH_BYTES)
+        if err is not None:
+            return err
+
+        if "html" not in content_type and not looks_like_html(body):
+            return truncate(body.strip(), self.max_page_chars)
+
+        return truncate(html_to_markdown(body, main_content=True), self.max_page_chars)
+
+    def _github_readme_api_url(self, url: str) -> Optional[str]:
+        parsed = urlparse(url)
+        host = (parsed.hostname or "").lower().lstrip("www.")
+        if host != "github.com":
+            return None
+        parts = [p for p in parsed.path.split("/") if p]
+        if len(parts) != 2:
+            return None
+        owner, repo = parts
+        if owner.lower() in _GITHUB_NON_OWNER_SEGMENTS:
+            return None
+        if repo.endswith(".git"):
+            repo = repo[:-4]
+        if not (_GITHUB_NAME_RE.match(owner) and _GITHUB_NAME_RE.match(repo)):
+            return None
+        return f"https://api.github.com/repos/{owner}/{repo}/readme"

web_search/config.py

@@ -0,0 +1,37 @@
+"""Shared constants for web_search."""
+
+MAX_FETCH_BYTES = 2 * 1024 * 1024        # 2 MB for normal pages
+MAX_PDF_FETCH_BYTES = 20 * 1024 * 1024   # 20 MB for PDFs
+MAX_PAGE_CHARS = 32_000                  # chars fed to LLM
+MIN_MAIN_CONTENT_CHARS = 200
+MAX_REDIRECTS = 5
+
+USER_AGENTS = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+    "(KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 "
+    "(KHTML, like Gecko) Version/17.4.1 Safari/605.1.15",
+    "Mozilla/5.0 (X11; Linux x86_64; rv:125.0) Gecko/20100101 Firefox/125.0",
+]
+
+UNICODE_BOM_CODECS = [
+    (b"\xff\xfe\x00\x00", "utf-32-le"),
+    (b"\x00\x00\xfe\xff", "utf-32-be"),
+    (b"\xff\xfe",         "utf-16-le"),
+    (b"\xfe\xff",         "utf-16-be"),
+    (b"\xef\xbb\xbf",     "utf-8-sig"),
+]
+
+BINARY_MAGIC = [
+    b"\x89PNG", b"GIF8", b"\xff\xd8\xff",  # images
+    b"PK\x03\x04",                          # zip/docx/xlsx
+    b"\x1f\x8b",                            # gzip
+    b"BZh",                                 # bzip2
+    b"\x7fELF",                             # ELF binary
+    b"MZ",                                  # Windows PE
+]
+
+TEXT_MIME_PREFIXES = (
+    "text/", "application/json", "application/xml",
+    "application/javascript", "application/xhtml",
+)

web_search/content.py

@@ -0,0 +1,41 @@
+"""Content-type detection helpers."""
+
+import re
+
+from web_search.config import BINARY_MAGIC, TEXT_MIME_PREFIXES
+
+_HTML_DOCUMENT_RE = re.compile(r"(<\?xml|<!doctype\s+html|<html[\s>])")
+
+
+def has_pdf_magic(data: bytes) -> bool:
+    return data[:4] == b"%PDF"
+
+
+def has_binary_magic(data: bytes) -> bool:
+    return any(data.startswith(sig) for sig in BINARY_MAGIC)
+
+
+def is_text_mime(content_type: str) -> bool:
+    ct = content_type.lower()
+    return any(ct.startswith(p) for p in TEXT_MIME_PREFIXES)
+
+
+def looks_binary(text: str, threshold: float = 0.02) -> bool:
+    """Heuristic: high ratio of control/replacement chars -> binary."""
+    if not text:
+        return False
+    ctrl = sum(
+        1 for ch in text
+        if ch == "�" or (ord(ch) < 32 and ch not in "\t\n\r")
+    )
+    return ctrl / len(text) > threshold
+
+
+def looks_like_html(body: str) -> bool:
+    probe = body.lstrip()[:512].lower()
+    return bool(re.search(r"<(html|head|body|div|p|span|script|meta)\b", probe))
+
+
+def looks_like_html_document(body: str) -> bool:
+    probe = body.lstrip()[:256].lower()
+    return bool(_HTML_DOCUMENT_RE.match(probe))

web_search/html.py

@@ -0,0 +1,61 @@
+"""HTML to Markdown converter and text truncation."""
+
+import re
+
+from web_search.config import MIN_MAIN_CONTENT_CHARS
+
+
+def html_to_markdown(html: str, main_content: bool = False) -> str:
+    try:
+        from bs4 import BeautifulSoup, Comment
+    except ImportError:
+        text = re.sub(r"<(script|style)[^>]*>.*?</\1>", "", html, flags=re.DOTALL | re.IGNORECASE)
+        text = re.sub(r"<!--.*?-->", "", text, flags=re.DOTALL)
+        text = re.sub(r"<[^>]+>", " ", text)
+        text = re.sub(r"[ \t]+", " ", text)
+        return re.sub(r"\n{3,}", "\n\n", text).strip()
+
+    soup = BeautifulSoup(html, "html.parser")
+
+    for tag in soup(["script", "style", "head", "noscript"]):
+        tag.decompose()
+    for tag in soup.find_all(True):
+        attrs = tag.attrs or {}
+        if attrs.get("hidden") or attrs.get("aria-hidden") == "true":
+            tag.decompose()
+    for comment in soup.find_all(string=lambda t: isinstance(t, Comment)):
+        comment.extract()
+
+    root = soup
+    if main_content:
+        for scope in ("article", "main"):
+            candidate = soup.find(scope)
+            if candidate:
+                text = candidate.get_text(separator="\n")
+                if len(text.strip()) >= MIN_MAIN_CONTENT_CHARS:
+                    root = candidate
+                    break
+
+    lines: list[str] = []
+    for el in root.descendants:
+        if not hasattr(el, "name"):
+            txt = str(el).strip()
+            if txt:
+                lines.append(txt)
+        elif el.name in ("h1", "h2", "h3", "h4", "h5", "h6"):
+            lines.append("\n" + "#" * int(el.name[1]) + " " + el.get_text(strip=True))
+        elif el.name == "li":
+            lines.append("- " + el.get_text(strip=True))
+        elif el.name in ("p", "br", "tr", "div"):
+            lines.append("")
+
+    text = "\n".join(lines)
+    return re.sub(r"\n{3,}", "\n\n", text).strip()
+
+
+def truncate(text: str, max_chars: int) -> str:
+    if not text:
+        return "(page returned no readable text)"
+    if len(text) > max_chars:
+        return text[:max_chars] + f"\n\n... (truncated, {len(text)} total chars)"
+    return text

web_search/http.py

@@ -0,0 +1,193 @@
+"""HTTP helpers: redirect suppression, SNI handler, body reader, PDF extractor."""
+
+import http.client
+import random
+import socket
+import ssl
+import urllib.error
+import urllib.request
+from typing import Optional
+
+from web_search.config import MAX_REDIRECTS, UNICODE_BOM_CODECS, USER_AGENTS
+from web_search.content import has_binary_magic, has_pdf_magic, is_text_mime, looks_binary
+from web_search.security import resolve_host
+
+from urllib.parse import urljoin, urlparse, urlunparse
+import re
+
+
+class _NoRedirect(urllib.request.HTTPErrorProcessor):
+    def http_response(self, request, response):
+        return response
+    https_response = http_response
+
+
+class _PinnedHTTPSConnection(http.client.HTTPSConnection):
+    """HTTPS connection to a pinned IP that presents the real hostname for SNI
+    and certificate validation."""
+
+    def __init__(self, host, sni_hostname: str, **kw):
+        kw.pop("context", None)
+        super().__init__(host, **kw)
+        self._sni_hostname = sni_hostname
+        self._ctx = ssl.create_default_context()
+
+    def connect(self):
+        sock = socket.create_connection((self.host, self.port), self.timeout)
+        self.sock = self._ctx.wrap_socket(sock, server_hostname=self._sni_hostname)
+
+
+class _SNIHTTPSHandler(urllib.request.HTTPSHandler):
+    def __init__(self, sni_hostname: str):
+        super().__init__()
+        self._sni = sni_hostname
+
+    def https_open(self, req):
+        return self.do_open(
+            lambda host, **kw: _PinnedHTTPSConnection(host, sni_hostname=self._sni, **kw),
+            req,
+        )
+
+
+def read_capped_body(resp, limit: int, chunk: int = 65536) -> tuple[Optional[str], bytes]:
+    chunks: list[bytes] = []
+    total = 0
+    try:
+        while True:
+            data = resp.read(min(chunk, limit - total))
+            if not data:
+                break
+            chunks.append(data)
+            total += len(data)
+            if total >= limit:
+                break
+    except Exception as e:
+        return f"Failed to read response body: {e}", b""
+    return None, b"".join(chunks)
+
+
+def extract_pdf_text(raw: bytes) -> str:
+    try:
+        import io
+        import pypdf
+        reader = pypdf.PdfReader(io.BytesIO(raw))
+        text = "\n".join(page.extract_text() or "" for page in reader.pages).strip()
+        if text:
+            return text
+    except Exception:
+        pass
+    try:
+        import io
+        from pdfminer.high_level import extract_text as pm_extract
+        return (pm_extract(io.BytesIO(raw)) or "").strip()
+    except Exception:
+        pass
+    return ""
+
+
+def fetch_raw(
+    url: str,
+    timeout: int,
+    max_fetch_bytes: int,
+    max_pdf_fetch_bytes: int,
+    extra_headers: Optional[dict] = None,
+) -> tuple[Optional[str], str, str]:
+    """Fetch URL with SSRF protection, DNS pinning, redirect following."""
+    parsed = urlparse(url)
+    if parsed.scheme not in ("http", "https"):
+        return f"Blocked: only http/https allowed (got {parsed.scheme!r}).", "", ""
+    if not parsed.hostname:
+        return "Blocked: URL missing hostname.", "", ""
+
+    port = parsed.port or (443 if parsed.scheme == "https" else 80)
+    ok, reason, pinned_ip = resolve_host(parsed.hostname, port)
+    if not ok:
+        return reason, "", ""
+
+    try:
+        current_url = url
+        current_host = parsed.hostname
+        ua = random.choice(USER_AGENTS)
+
+        for _ in range(MAX_REDIRECTS):
+            cp = urlparse(current_url)
+            ip_str = f"[{pinned_ip}]" if ":" in pinned_ip else pinned_ip
+            ip_netloc = f"{ip_str}:{cp.port}" if cp.port else ip_str
+            pinned_url = urlunparse(cp._replace(netloc=ip_netloc))
+
+            opener = urllib.request.build_opener(_NoRedirect, _SNIHTTPSHandler(current_host))
+            headers = {"User-Agent": ua, "Host": current_host}
+            if extra_headers:
+                headers.update(extra_headers)
+
+            req = urllib.request.Request(pinned_url, headers=headers)
+            try:
+                resp = opener.open(req, timeout=timeout)
+            except urllib.error.HTTPError as e:
+                if e.code not in (301, 302, 303, 307, 308):
+                    return f"Failed to fetch URL: HTTP {e.code} {getattr(e, 'reason', '')}", "", ""
+                location = e.headers.get("Location")
+                if not location:
+                    return "Failed to fetch: redirect missing Location.", "", ""
+                current_url = urljoin(current_url, location)
+                rp = urlparse(current_url)
+                if rp.scheme not in ("http", "https") or not rp.hostname:
+                    return "Blocked: redirect target not valid http/https.", "", ""
+                rp_port = rp.port or (443 if rp.scheme == "https" else 80)
+                ok2, reason2, pinned_ip = resolve_host(rp.hostname, rp_port)
+                if not ok2:
+                    return reason2, "", ""
+                current_host = rp.hostname
+                continue
+
+            content_type = (resp.headers.get_content_type() or "").lower() if resp.headers.get("Content-Type") else ""
+            declared_pdf = content_type == "application/pdf"
+            read_limit = max_pdf_fetch_bytes + 1 if declared_pdf else max_fetch_bytes
+            err, raw_bytes = read_capped_body(resp, read_limit)
+            if err:
+                return err, "", ""
+
+            if not declared_pdf and len(raw_bytes) == max_fetch_bytes and has_pdf_magic(raw_bytes):
+                err2, tail = read_capped_body(resp, max_pdf_fetch_bytes - max_fetch_bytes + 1)
+                if err2:
+                    return err2, "", ""
+                raw_bytes += tail
+
+            break
+        else:
+            return "Failed to fetch: too many redirects.", "", ""
+
+        is_pdf = declared_pdf or has_pdf_magic(raw_bytes)
+        if is_pdf:
+            if len(raw_bytes) > max_pdf_fetch_bytes:
+                return "(PDF exceeds download limit)", "", content_type
+            pdf_text = extract_pdf_text(raw_bytes)
+            return None, pdf_text or "(PDF contains no extractable text)", "application/pdf"
+
+        if content_type and not is_text_mime(content_type):
+            m = re.match(r"[\w.+-]+/[\w.+-]+", content_type)
+            return f"(non-text content: {m.group(0) if m else 'unknown type'})", "", content_type
+
+        if has_binary_magic(raw_bytes):
+            return f"(binary content, {len(raw_bytes)} bytes)", "", content_type
+
+        declared_enc = resp.headers.get_content_charset()
+        bom_codec = next((c for bom, c in UNICODE_BOM_CODECS if raw_bytes.startswith(bom)), None)
+        text = raw_bytes.decode(declared_enc or bom_codec or "utf-8", errors="replace")
+
+        if looks_binary(text):
+            if declared_enc in (None, "iso8859-1"):
+                alt = raw_bytes.decode("cp1252", "replace")
+                if not looks_binary(alt):
+                    text = alt
+                else:
+                    return f"(binary content, {len(raw_bytes)} bytes)", "", content_type
+            else:
+                return f"(binary content, {len(raw_bytes)} bytes)", "", content_type
+
+        return None, text, content_type
+
+    except urllib.error.HTTPError as e:
+        return f"Failed to fetch URL: HTTP {e.code} {getattr(e, 'reason', '')}", "", ""
+    except Exception as e:
+        return f"Failed to fetch URL: {e}", "", ""

web_search/security.py

@@ -0,0 +1,49 @@
+"""SSRF protection: private-IP detection and DNS resolution with pinning."""
+
+import socket
+
+
+def is_private_ip(ip: str) -> bool:
+    """Return True if the IP is loopback, private, or link-local."""
+    try:
+        packed = socket.inet_pton(socket.AF_INET6 if ":" in ip else socket.AF_INET, ip)
+    except OSError:
+        return True  # unparseable -> block
+    if ":" in ip:
+        # IPv6 loopback ::1, link-local fe80::/10, ULA fc00::/7
+        if packed == b"\x00" * 15 + b"\x01":
+            return True
+        if packed[0] in (0xFE, 0xFF) and (packed[1] & 0xC0) == 0x80:
+            return True
+        if packed[0] in (0xFC, 0xFD):
+            return True
+    else:
+        a, b = packed[0], packed[1]
+        if a == 127:
+            return True
+        if a == 10:
+            return True
+        if a == 172 and 16 <= b <= 31:
+            return True
+        if a == 192 and b == 168:
+            return True
+        if a == 169 and b == 254:
+            return True
+    return False
+
+
+def resolve_host(hostname: str, port: int) -> tuple[bool, str, str]:
+    """
+    Resolve hostname -> IP with SSRF validation.
+    Returns (ok, reason_or_empty, pinned_ip).
+    """
+    try:
+        infos = socket.getaddrinfo(hostname, port, type=socket.SOCK_STREAM)
+    except socket.gaierror as e:
+        return False, f"Blocked: DNS resolution failed for {hostname!r}: {e}", ""
+    if not infos:
+        return False, f"Blocked: no address found for {hostname!r}.", ""
+    ip = infos[0][4][0]
+    if is_private_ip(ip):
+        return False, f"Blocked: {hostname!r} resolves to a private/loopback address.", ""
+    return True, "", ip

web_search/server.py

@@ -0,0 +1,40 @@
+"""MCP server module for web_search — can be run standalone or imported as a library."""
+
+import asyncio
+import os
+
+from mcp.server.fastmcp import FastMCP
+
+from web_search.client import WebSearchClient
+
+HOST = os.getenv("MCP_HOST", "0.0.0.0")
+PORT = int(os.getenv("MCP_PORT", "8787"))
+TRANSPORT = os.getenv("MCP_TRANSPORT", "streamable-http")  # streamable-http | sse | stdio
+
+mcp = FastMCP("web-search", host=HOST, port=PORT)
+
+_client = WebSearchClient(
+    max_results=int(os.getenv("SEARCH_MAX_RESULTS", "5")),
+    timeout=int(os.getenv("SEARCH_TIMEOUT", "30")),
+)
+
+
+@mcp.tool()
+async def web_search(query: str) -> str:
+    """Search the web using DuckDuckGo. Returns title, URL, and snippet for each result."""
+    return await asyncio.to_thread(_client.search, query)
+
+
+@mcp.tool()
+async def web_fetch(url: str) -> str:
+    """Fetch a web page and return its readable text content (HTML -> Markdown, PDF -> text)."""
+    return await asyncio.to_thread(_client.fetch, url)
+
+
+def main():
+    """Entry point for the web-search-server console script."""
+    mcp.run(transport=TRANSPORT)
+
+
+if __name__ == "__main__":
+    main()

websift-0.1.0.dist-info/METADATA

@@ -0,0 +1,757 @@
+Metadata-Version: 2.4
+Name: websift
+Version: 0.1.0
+Summary: Self-hosted MCP server for web search (DuckDuckGo) + page fetching. No API key required.
+Author-email: HuyPP03 <huypp03@users.noreply.github.com>
+License: MIT
+Project-URL: Homepage, https://github.com/HuyPP03/websift
+Project-URL: Repository, https://github.com/HuyPP03/websift
+Project-URL: Issues, https://github.com/HuyPP03/websift/issues
+Keywords: mcp,web-search,duckduckgo,ai-agent,tool-use,websift
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.9.0
+Requires-Dist: ddgs>=9.0.0
+Requires-Dist: beautifulsoup4>=4.12.0
+Requires-Dist: pypdf>=4.0.0
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+ 
+
+# websift
+
+A lightweight, **free, self-hosted MCP (Model Context Protocol) server** that gives AI agents real-time web access — DuckDuckGo search + web page fetching (HTML → Markdown, PDF → text) — with built-in SSRF protection and DNS pinning. **No API key required.**
+
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/)
+[![PyPI](https://img.shields.io/badge/PyPI-websift-orange.svg)](https://pypi.org/project/websift/)
+[![MCP](https://img.shields.io/badge/MCP-streamable--http-green.svg)](https://modelcontextprotocol.io/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+---
+
+## Table of Contents
+
+- [What It Does](#what-it-does)
+- [Why Use This](#why-use-this)
+- [Comparison with Alternatives](#comparison-with-alternatives)
+- [Architecture](#architecture)
+- [Installation](#installation)
+  - [Option 1: PyPI (Recommended)](#option-1-pypi-recommended)
+  - [Option 2: Docker Compose](#option-2-docker-compose)
+  - [Option 3: Docker (Manual)](#option-3-docker-manual)
+  - [Option 4: Local Python (No Docker)](#option-4-local-python-no-docker)
+- [Usage](#usage)
+  - [As a Python Library (Direct Import)](#as-a-python-library-direct-import)
+  - [As an MCP Server (For AI Clients)](#as-an-mcp-server-for-ai-clients)
+- [Tools](#tools)
+- [Configuration](#configuration)
+- [Connecting to AI Clients](#connecting-to-ai-clients)
+  - [VS Code (GitHub Copilot)](#1-vs-code-github-copilot)
+  - [Claude Desktop](#2-claude-desktop)
+  - [Claude Code](#3-claude-code)
+  - [Copilot CLI](#4-copilot-cli)
+  - [Cursor](#5-cursor)
+  - [Windsurf (Codeium)](#6-windsurf-codeium)
+  - [JetBrains IDEs](#7-jetbrains-ides)
+  - [Any MCP Client (Generic)](#8-any-mcp-client-generic)
+- [Use Cases](#use-cases)
+- [Security](#security)
+- [Development](#development)
+- [FAQ](#faq)
+
+---
+
+## What It Does
+
+This MCP server exposes two tools to any AI agent or LLM client:
+
+| Tool           | Input              | Output                                                                 |
+| -------------- | ------------------ | ---------------------------------------------------------------------- |
+| `web_search` | `query` (string) | Title, URL, and snippet for each DuckDuckGo result                     |
+| `web_fetch`  | `url` (string)   | Readable text content from any webpage (HTML → Markdown, PDF → text) |
+
+That's it — simple, focused, and reliable.
+
+---
+
+## Why Use This
+
+### Core Strengths
+
+- **🆓 Completely Free** — No API keys, no subscriptions, no rate limits from a third-party provider. DuckDuckGo is free, and this server is free.
+- **🪶 Lightweight** — Single Python process, ~4 dependencies, runs in a tiny Docker container (`python:3.12-slim` ≈ 150 MB).
+- **🔒 Secure by Default** — SSRF protection with private-IP blocking, DNS resolution pinning, SNI validation, redirect limits, and content-type validation.
+- **🌐 Universal MCP Compatibility** — Works with any MCP client (VS Code, Claude, Cursor, Windsurf, JetBrains, custom agents, etc.).
+- **📄 Smart Content Extraction** — HTML → clean Markdown via BeautifulSoup, PDF → text via pypdf/pdfminer, binary detection, charset auto-detection.
+- **🐙 GitHub README Shortcut** — Fetching a `github.com/owner/repo` URL automatically uses the GitHub API to grab the raw README.
+- **🏠 Self-Hosted** — Full control over your data. No traffic routed through third-party services.
+
+### Ideal For
+
+- **🐍 Python Scripts & Apps** — Import `WebSearchClient` directly in your code. No server, no Docker, no MCP overhead.
+- **AI Agents & Agentic Workflows** — Give any autonomous agent the ability to search the web and read pages on demand.
+- **Development Assistants** — Let Copilot, Claude, or Cursor look up documentation, error messages, or package info in real time.
+- **Research & Analysis** — Fetch and summarize articles, papers, or documentation pages.
+- **Cost-Sensitive Deployments** — Replace paid web-search APIs (Tavily, Firecrawl, Exa, etc.) with a free self-hosted alternative.
+- **Air-Gapped / Private Networks** — Run entirely offline (search requires internet, but fetch can work with internal URLs if you adjust security rules).
+
+---
+
+## Comparison with Alternatives
+
+| Feature                    | **websift** | Tavily MCP                  | Firecrawl MCP         | Exa MCP               | Brave Search MCP            |
+| -------------------------- | ------------------------ | --------------------------- | --------------------- | --------------------- | --------------------------- |
+| **Price**            | ✅ Free                  | 💰 Paid (free tier limited) | 💰 Paid               | 💰 Paid               | 💰 Paid (free tier limited) |
+| **API Key Required** | ✅ No                    | ❌ Yes                      | ❌ Yes                | ❌ Yes                | ❌ Yes                      |
+| **Self-Hosted**      | ✅ Yes                   | ❌ No                       | ⚠️ Partial          | ❌ No                 | ❌ No                       |
+| **Web Search**       | ✅ DuckDuckGo            | ✅ Proprietary              | ❌ (scrape only)      | ✅ Proprietary        | ✅ Brave                    |
+| **Web Fetch**        | ✅ HTML + PDF            | ✅ Yes                      | ✅ Yes (deep)         | ✅ Yes                | ❌ No                       |
+| **SSRF Protection**  | ✅ Built-in              | ⚠️ Managed                | ⚠️ Managed          | ⚠️ Managed          | ⚠️ Managed                |
+| **Container Size**   | ~150 MB                  | N/A (SaaS)                  | ~500 MB+              | N/A (SaaS)            | N/A (SaaS)                  |
+| **Dependencies**     | 4 packages               | N/A                         | Many                  | N/A                   | N/A                         |
+| **Rate Limits**      | DuckDuckGo only          | Provider limits             | Provider limits       | Provider limits       | Provider limits             |
+| **Privacy**          | ✅ Full control          | ⚠️ Data to provider       | ⚠️ Data to provider | ⚠️ Data to provider | ⚠️ Data to provider       |
+
+### When to Choose What
+
+| Scenario                                                               | Recommended                 |
+| ---------------------------------------------------------------------- | --------------------------- |
+| You want**free, no-signup** web access for AI                    | **websift** ✅ |
+| You need**deep scraping** (JS-rendered pages, sitemaps)          | Firecrawl                   |
+| You need**semantic search** (AI-powered relevance)               | Exa                         |
+| You want**agentic-optimized** search (Tavily's `extract` mode) | Tavily                      |
+| You need**maximum privacy** (self-hosted, no external calls)     | **websift** ✅ |
+| You're building a**custom AI agent** with minimal infra          | **websift** ✅ |
+
+---
+
+## Architecture
+
+```
+┌─────────────┐     MCP Protocol      ┌──────────────────┐
+│  AI Client  │ ◄── (streamable-HTTP) ┤   MCP Server     │
+│  (Copilot,  │                       │   (FastMCP)      │
+│   Claude,   │                       └─────────┬────────┘
+│   Cursor…)  │                                 │
+└─────────────┘                    ┌────────────┴─────────┐
+                                   │  WebSearchClient     │
+┌────────────┐                     │                      │
+│  search()  │──► DuckDuckGo (ddgs)│                      │   
+│  fetch()   │──► urllib + SSRF    │                      │
+│            │    ├── html.py (BS4)│                      │
+│            │    ├── http.py      │                      │
+│            │    ├── security.py  │                      │
+│            │    └── content.py   │                      │
+└────────────┘                     └──────────────────────┘
+```
+
+### Module Structure
+
+```
+web_search/
+├── __init__.py    # exports WebSearchClient + __version__
+├── config.py      # constants (size limits, user-agents, MIME types, ...)
+├── security.py    # SSRF protection: private-IP check, DNS resolve + pin
+├── content.py     # content-type detection (PDF, binary, HTML heuristics)
+├── http.py        # raw HTTP fetch: redirect following, SNI pinning, charset decode
+├── html.py        # HTML → Markdown conversion, text truncation
+├── client.py      # WebSearchClient: search / fetch / GitHub README shortcut
+└── server.py      # MCP server module (FastMCP, importable or standalone)
+server.py          # thin entry point → delegates to web_search.server
+```
+
+---
+
+## Installation
+
+### Option 1: PyPI (Recommended)
+
+```bash
+pip install websift
+```
+
+That's it — you can now use it as a **Python library** (direct import) or as an **MCP server** (for AI clients).
+
+### Option 2: Docker Compose
+
+```bash
+# Clone and start
+git clone <repo-url>
+cd websift
+docker compose up -d --build
+```
+
+The MCP server will be available at `http://localhost:8787/mcp`.
+
+### Option 3: Docker (Manual)
+
+```bash
+docker build -t websift .
+docker run -d --name websift -p 8787:8787 websift
+```
+
+### Option 4: Local Python (No Docker)
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the server
+python server.py
+```
+
+---
+
+## Usage
+
+### As a Python Library (Direct Import)
+
+Use `WebSearchClient` directly in your Python code — **no server needed**:
+
+```python
+from web_search import WebSearchClient
+
+client = WebSearchClient()
+
+# Search the web (DuckDuckGo)
+results = client.search("Python 3.12 features")
+print(results)
+
+# Fetch a web page (HTML → Markdown, PDF → text)
+content = client.fetch("https://docs.python.org/3/")
+print(content)
+```
+
+**Perfect for:**
+
+- Custom scripts & automation
+- Embedding in your own applications
+- Data pipelines & ETL workflows
+- Testing & prototyping
+
+### As an MCP Server (For AI Clients)
+
+Run the server to expose tools to any MCP-compatible AI client:
+
+```bash
+# Start the server (default: port 8787)
+websift
+
+# Custom port & transport
+MCP_PORT=9000 MCP_TRANSPORT=sse websift
+```
+
+Or via Python:
+
+```python
+from web_search.server import main
+main()
+```
+
+**Perfect for:**
+
+- VS Code (GitHub Copilot)
+- Claude Desktop / Claude Code
+- Cursor, Windsurf, JetBrains IDEs
+- Any MCP-compatible agent
+
+---
+
+## Tools
+
+### `web_search(query: str) -> str`
+
+Searches DuckDuckGo and returns formatted results with title, URL, and snippet.
+
+**Example:**
+
+```
+Agent: web_search("latest Python 3.12 features")
+Server:
+Title: What's New in Python 3.12
+URL: https://docs.python.org/3/whatsnew/3.12.html
+Snippet: Python 3.12 introduces several performance improvements...
+
+---
+
+Title: Python 3.12 Release Notes
+URL: https://www.python.org/downloads/release/python-3120/
+Snippet: The Python 3.12 release includes bug fixes and...
+```
+
+### `web_fetch(url: str) -> str`
+
+Fetches a URL and returns readable text content. Handles:
+
+- **HTML pages** → converted to clean Markdown (BeautifulSoup, main-content extraction)
+- **PDF files** → text extracted via pypdf / pdfminer
+- **Plain text / JSON / XML** → returned as-is
+- **GitHub repos** → automatically fetches README via GitHub API
+- **Binary files** → detected and blocked (images, executables, archives)
+
+**Example:**
+
+```
+Agent: web_fetch("https://github.com/python/cpython")
+Server:
+README of https://github.com/python/cpython (via GitHub API):
+
+# Python
+The Python programming language...
+```
+
+---
+
+## Configuration
+
+### Environment Variables
+
+| Variable               | Default             | Description                                          |
+| ---------------------- | ------------------- | ---------------------------------------------------- |
+| `MCP_HOST`           | `0.0.0.0`         | Bind address                                         |
+| `MCP_PORT`           | `8787`            | Listen port                                          |
+| `MCP_TRANSPORT`      | `streamable-http` | Transport:`streamable-http`, `sse`, or `stdio` |
+| `SEARCH_MAX_RESULTS` | `5`               | Max search results returned                          |
+| `SEARCH_TIMEOUT`     | `30`              | Request timeout in seconds                           |
+
+### Internal Limits
+
+| Setting          | Value  | Description               |
+| ---------------- | ------ | ------------------------- |
+| Max page size    | 2 MB   | Normal page fetch limit   |
+| Max PDF size     | 20 MB  | PDF fetch limit           |
+| Max output chars | 32,000 | Characters sent to LLM    |
+| Max redirects    | 5      | HTTP redirect chain limit |
+
+---
+
+## Connecting to AI Clients
+
+### 1. VS Code (GitHub Copilot)
+
+> 📖 **Official docs**: [Add and manage MCP servers in VS Code](https://code.visualstudio.com/docs/agent-customization/mcp-servers) | [MCP configuration reference](https://code.visualstudio.com/docs/agents/reference/mcp-configuration)
+
+#### Via Extensions View (Easiest)
+
+1. Open Extensions view (`Ctrl+Shift+X`)
+2. Search `@mcp` in the search field
+3. Install any MCP server from the gallery
+
+#### Via `mcp.json` (Custom Server)
+
+Create `.vscode/mcp.json` in your workspace:
+
+```json
+{
+  "mcpServers": {
+    "web-search": {
+      "type": "http",
+      "url": "http://localhost:8787/mcp"
+    }
+  }
+}
+```
+
+Or for global (user-level) configuration, run `MCP: Open User Configuration` from the Command Palette and add the same entry.
+
+#### Verify
+
+Open Chat (`Ctrl+Cmd+I` / `Ctrl+Ctrl+I`) and ask: *"Search for the latest Python release notes"*
+
+### 2. Claude Desktop
+
+> 📖 **Official docs**: [Getting Started with Local MCP Servers on Claude Desktop](https://support.claude.com/en/articles/10949351-getting-started-with-local-mcp-servers-on-claude-desktop) | [Desktop Extensions](https://www.anthropic.com/engineering/desktop-extensions)
+
+#### Via Settings UI
+
+1. Open Claude Desktop → Settings → Extensions
+2. Click "Advanced settings" → "Install Extension…"
+3. Or manually add via the configuration file
+
+#### Via Configuration File
+
+Edit `~/.config/claude/claude_desktop_config.json` (Linux) or `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS):
+
+```json
+{
+  "mcpServers": {
+    "web-search": {
+      "url": "http://localhost:8787/mcp"
+    }
+  }
+}
+```
+
+Restart Claude Desktop after editing.
+
+### 3. Claude Code
+
+> 📖 **Official docs**: [Connect Claude Code to tools via MCP](https://code.claude.com/docs/en/mcp)
+
+```bash
+# Add the MCP server (HTTP transport)
+claude mcp add --transport http web-search http://localhost:8787/mcp
+
+# Verify it's connected
+claude mcp list
+
+# Use it in conversation
+claude "Search for the latest Rust release and summarize the key changes"
+```
+
+**Scopes:**
+
+```bash
+# Project scope (default, stored in .mcp.json)
+claude mcp add --transport http web-search http://localhost:8787/mcp
+
+# User scope (available across all projects)
+claude mcp add --transport http web-search --scope user http://localhost:8787/mcp
+```
+
+### 4. Copilot CLI
+
+> 📖 **Official docs**: [Adding MCP servers for GitHub Copilot CLI](https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-mcp-servers)
+
+#### Interactive Mode
+
+```
+/mcp add
+# Server Name: web-search
+# Server Type: HTTP
+# URL: http://localhost:8787/mcp
+# Press Ctrl+S to save
+```
+
+#### Command Line
+
+```bash
+copilot mcp add web-search --transport http --url http://localhost:8787/mcp
+```
+
+#### Config File
+
+Edit `~/.github/copilot/mcp-config.json`:
+
+```json
+{
+  "mcpServers": {
+    "web-search": {
+      "type": "http",
+      "url": "http://localhost:8787/mcp"
+    }
+  }
+}
+```
+
+### 5. Cursor
+
+> 📖 **Official docs**: [Model Context Protocol (MCP) | Cursor Docs](https://cursor.com/docs/mcp)
+
+Create `~/.cursor/mcp.json` (global) or `.cursor/mcp.json` (project):
+
+```json
+{
+  "mcpServers": {
+    "web-search": {
+      "type": "http",
+      "url": "http://localhost:8787/mcp"
+    }
+  }
+}
+```
+
+Restart Cursor, then use Chat or Agent mode to invoke the tools.
+
+### 6. Windsurf (Codeium)
+
+> 📖 **Official docs**: [Cascade MCP Integration](https://docs.windsurf.com/plugins/cascade/mcp)
+
+Create `~/.codeium/windsurf/mcp_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "web-search": {
+      "type": "http",
+      "url": "http://localhost:8787/mcp"
+    }
+  }
+}
+```
+
+Alternatively, use the built-in UI: **Settings → Cascade → MCP Servers**.
+
+### 7. JetBrains IDEs
+
+> 📖 **Official docs**: [MCP Server | IntelliJ IDEA Documentation](https://www.jetbrains.com/help/idea/mcp-server.html)
+
+1. Install the "MCP Client" plugin from the JetBrains Marketplace
+2. Go to **Settings → Tools → MCP**
+3. Add a new server:
+   - Name: `web-search`
+   - Type: `HTTP`
+   - URL: `http://localhost:8787/mcp`
+4. Apply and restart
+
+### 8. Any MCP Client (Generic)
+
+For any MCP-compatible client, the server is accessible at:
+
+- **Streamable HTTP** (recommended): `http://localhost:8787/mcp`
+- **SSE**: `http://localhost:8787/mcp/sse` (set `MCP_TRANSPORT=sse`)
+- **STDIO**: Run `python server.py` with `MCP_TRANSPORT=stdio`
+
+Generic HTTP configuration:
+
+```json
+{
+  "mcpServers": {
+    "web-search": {
+      "type": "http",
+      "url": "http://localhost:8787/mcp"
+    }
+  }
+}
+```
+
+---
+
+## Use Cases
+
+### AI Agent Web Research
+
+```
+User: "Find the latest benchmarks for LLM inference optimization"
+Agent: web_search("LLM inference optimization benchmarks 2025")
+Agent: web_fetch("https://example.com/benchmark-article")
+Agent: [Summarizes findings from fetched content]
+```
+
+### Documentation Lookup
+
+```
+User: "How do I configure CORS in FastAPI?"
+Agent: web_search("FastAPI CORS configuration")
+Agent: web_fetch("https://fastapi.tiangolo.com/tutorial/cors/")
+Agent: [Provides code example from documentation]
+```
+
+### Error Debugging
+
+```
+User: "I'm getting 'ModuleNotFoundError: no module named '_sqlite3'"
+Agent: web_search("ModuleNotFoundError _sqlite3 Python Docker")
+Agent: [Finds solution: install python3-dev packages]
+```
+
+### Competitive Analysis
+
+```
+User: "What are the latest features in React 19?"
+Agent: web_search("React 19 new features")
+Agent: web_fetch("https://react.dev/blog/2024")
+Agent: [Summarizes new features]
+```
+
+### Agentic AI Workflows
+
+This server is particularly well-suited for agentic AI because:
+
+- **Deterministic tools** — `web_search` and `web_fetch` have clear, predictable inputs and outputs.
+- **No authentication overhead** — agents don't need to manage API keys.
+- **Self-contained** — single container, no external dependencies beyond DuckDuckGo.
+- **SSRF-safe** — agents can safely fetch URLs without risking internal network exposure.
+- **Markdown output** — clean, structured text that LLMs can process efficiently.
+
+---
+
+## Security
+
+### Built-in Protections
+
+| Protection                  | How It Works                                                                                  |
+| --------------------------- | --------------------------------------------------------------------------------------------- |
+| **SSRF Prevention**   | All resolved IPs are checked against private/loopback/link-local ranges                       |
+| **DNS Pinning**       | DNS resolution is pinned to the first resolved IP; SNI validation ensures certificate matches |
+| **Redirect Limits**   | Maximum 5 redirects to prevent redirect loops and SSRF bypass                                 |
+| **Scheme Validation** | Only`http://` and `https://` schemes are allowed                                          |
+| **Binary Detection**  | Images, executables, archives, and other binary content are detected and blocked              |
+| **Size Limits**       | 2 MB for normal pages, 20 MB for PDFs, 32,000 chars output limit                              |
+| **Charset Detection** | BOM detection (UTF-8/16/32), Content-Type header parsing, meta tag fallback                   |
+
+### Network Considerations
+
+- The server binds to `0.0.0.0` by default — restrict with `MCP_HOST=127.0.0.1` for local-only access.
+- No authentication is built in — place behind a reverse proxy (nginx, Caddy) if exposing externally.
+- Docker Compose isolates the server in its own container network.
+
+---
+
+## Development
+
+### Project Structure
+
+```
+websift/
+├── pyproject.toml          # Package metadata, dependencies, console script
+├── docker-compose.yml      # Docker Compose setup
+├── Dockerfile              # Python 3.12-slim container
+├── requirements.txt        # Python dependencies
+├── server.py               # MCP server entry point (delegates to web_search.server)
+├── .env.example            # Environment variable template
+├── .mcp.json               # VS Code MCP configuration
+├── README.md               # This file
+├── docs/
+│   └── README.vi.md        # Vietnamese documentation
+└── web_search/
+    ├── __init__.py         # Package exports (WebSearchClient, __version__)
+    ├── config.py           # Constants and configuration
+    ├── security.py         # SSRF protection and DNS pinning
+    ├── content.py          # Content-type detection
+    ├── http.py             # HTTP fetching with SNI pinning
+    ├── html.py             # HTML to Markdown conversion
+    ├── client.py           # WebSearchClient (search + fetch)
+    └── server.py           # MCP server module (importable or standalone)
+```
+
+### Running Locally
+
+```bash
+# Install from PyPI
+pip install websift
+
+# Or install in editable mode (for development)
+pip install -e .
+
+# Run as MCP server
+websift
+
+# Run with custom settings
+MCP_PORT=9000 MCP_TRANSPORT=sse websift
+
+# Or use as a library (no server needed)
+python -c "from web_search import WebSearchClient; print(WebSearchClient().search('test'))"
+```
+
+### Running with Docker
+
+```bash
+# Build and start
+docker compose up -d --build
+
+# View logs
+docker compose logs -f
+
+# Stop
+docker compose down
+```
+
+---
+
+## FAQ
+
+### Q: Does this require an API key?
+
+**No.** DuckDuckGo search is free and doesn't require authentication. The entire server runs without any API keys.
+
+### Q: Can I use this behind a firewall?
+
+Yes. The server only needs outbound HTTPS access to reach DuckDuckGo and target websites. Inbound access is only needed for the MCP endpoint (port 8787).
+
+### Q: How does this compare to Tavily or Firecrawl?
+
+This is simpler and free, but doesn't offer JS rendering, deep scraping, or semantic search. For basic web search + page fetching, it's a solid free alternative. See the [Comparison table](#comparison-with-alternatives) for details.
+
+### Q: Can I add authentication?
+
+The server itself doesn't include auth, but you can place it behind nginx/Caddy with basic auth or API key validation:
+
+```nginx
+location /mcp {
+    auth_basic "MCP Server";
+    auth_basic_user_file /etc/nginx/.htpasswd;
+    proxy_pass http://localhost:8787/mcp;
+}
+```
+
+### Q: What transport protocols are supported?
+
+- **streamable-http** (recommended, default) — modern MCP standard
+- **sse** — legacy Server-Sent Events (still supported)
+- **stdio** — for local process communication
+
+### Q: Why is the output limited to 32,000 characters?
+
+This keeps responses within typical LLM context windows while providing substantial content. You can adjust `MAX_PAGE_CHARS` in `web_search/config.py` if needed.
+
+### Q: Can I use this for internal/private websites?
+
+By default, SSRF protection blocks private IP ranges. To allow internal sites, modify `web_search/security.py` to whitelist specific domains or IP ranges.
+
+### Q: Can I use this as a Python library (without MCP)?
+
+**Yes!** Just `pip install websift` and import directly:
+
+```python
+from web_search import WebSearchClient
+client = WebSearchClient()
+client.search("your query")
+client.fetch("https://example.com")
+```
+
+No server, no Docker, no MCP overhead — just pure Python.
+
+### Q: Can I publish my own version to PyPI?
+
+Yes. After making changes:
+
+```bash
+# Install build tools
+pip install build twine
+
+# Build the package
+python -m build
+
+# Test upload (TestPyPI)
+twine upload --repository testpypi dist/*
+
+# Real upload (PyPI)
+twine upload dist/*
+```
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE) for details.
+
+## Acknowledgments
+
+- [DuckDuckGo Search (ddgs)](https://github.com/deedy5/ddgs) — search backend
+- [BeautifulSoup](https://www.crummy.com/software/BeautifulSoup/) — HTML parsing
+- [pypdf](https://pypdf.readthedocs.io/) — PDF text extraction
+- [FastMCP](https://github.com/modelcontextprotocol/python-sdk) — MCP server framework
+- [Model Context Protocol](https://modelcontextprotocol.io/) — open protocol for AI tool integration
+- [VS Code MCP Documentation](https://code.visualstudio.com/docs/agent-customization/mcp-servers) — official VS Code MCP guide
+- [Claude Code MCP Documentation](https://code.claude.com/docs/en/mcp) — official Claude Code MCP guide
+- [Cursor MCP Documentation](https://cursor.com/docs/mcp) — official Cursor MCP guide
+- [Windsurf MCP Documentation](https://docs.windsurf.com/plugins/cascade/mcp) — official Windsurf MCP guide
+- [Copilot CLI MCP Documentation](https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-mcp-servers) — official GitHub Copilot CLI MCP guide
+- [Claude Desktop MCP Documentation](https://support.claude.com/en/articles/10949351-getting-started-with-local-mcp-servers-on-claude-desktop) — official Claude Desktop MCP guide
+- [JetBrains MCP Documentation](https://www.jetbrains.com/help/idea/mcp-server.html) — official JetBrains MCP guide

websift-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+web_search/__init__.py,sha256=7Lw2-jl7HOQJ7sKecOS73ERYLWe4OlC2SGE6l0K2OMc,380
+web_search/client.py,sha256=XYV9WMpo43y0Bm70TK0Vob0Ugqjqzq9Q_mroJiBwix4,3839
+web_search/config.py,sha256=I5hjbcyfOzQJx_Vfvkk-R8mX-NJk28U_wyktkgoxsLw,1331
+web_search/content.py,sha256=CKFwuTKUmIklblQoCmsd9gYTZB-dx8d9u05MscRaEVI,1130
+web_search/html.py,sha256=NofkAMlsSCwQO1LTgWNaVZ6BFaSQTv3aNDq-ECGg1OY,2132
+web_search/http.py,sha256=laHZNBf1gmA5biH8Y8FsAimDnwkTelm9rSvVyXgugMg,7357
+web_search/security.py,sha256=fifCA4YV8MYmRkY8ce8UKOJ3RhjuCpCjy9g6SyqC_f4,1635
+web_search/server.py,sha256=fbzeT2pX20gE1b0OS2O728BBnbuMTKIuxHzT0GMvIeU,1130
+websift-0.1.0.dist-info/licenses/LICENSE,sha256=YM8wFZKmV0P_kbn_LRcnQY21isWS_Tx15xmTGPKD1EA,1084
+websift-0.1.0.dist-info/METADATA,sha256=QZbAZTe-rNA26aIt4y_jUjUTUi912LWB2KoV5GsXOhk,27279
+websift-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+websift-0.1.0.dist-info/entry_points.txt,sha256=7pLKLW73kk9j5U1zNNma1C-4KjRs_ys3lPrwA0KaV00,51
+websift-0.1.0.dist-info/top_level.txt,sha256=PoNm8MJYw_y8RTMaNlY0ePLoNHxVUAE2IHDuL5fFubI,11
+websift-0.1.0.dist-info/RECORD,,

websift-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

websift-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+websift = web_search.server:main

websift-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 web-search-mcp contributors
+
+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.

websift-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+web_search