Update app.py

app.py

@@ -1,13 +1,10 @@
 # File: main/app.py
-# Purpose: One Space that offers three tools in one MCP server:
-#          1) Fetch — extract relevant page content (title, metadata, clean text, hyperlinks)
-#          2) Websearch — structured DuckDuckGo results (JSON via LangChain wrapper)
-#          3) DDG (Unstructured) — compact plain-text DuckDuckGo results for low token usage
+# Purpose: One Space that offers three tools/tabs:
+#   1) Fetch — extract relevant page content (title, metadata, clean text, hyperlinks)
+#   2) Websearch — structured DuckDuckGo search via LangChain tool (JSON)
+#   3) Unstructured DDG — raw DuckDuckGo list[dict] rendered into a Textbox (matches your app)
 #
-# Notes:
-# - Launched with mcp_server=True so all functions are exposed as MCP tools.
-# - UI uses TabbedInterface: each tool has its own tab.
-# - Inline comments describe each section in plain language.
+# Launched with mcp_server=True so all functions are available as MCP tools.
 
 from __future__ import annotations
 
@@ -20,10 +17,9 @@ from bs4 import BeautifulSoup                     # (layman) for parsing HTML
 from readability import Document                  # (layman) to isolate main readable content
 from urllib.parse import urljoin, urldefrag, urlparse  # (layman) to fix/clean URLs
 
-# Structured DDG search (LangChain wrapper)
+# Structured search via LangChain community tool
 from langchain_community.tools import DuckDuckGoSearchResults
-
-# Unstructured DDG search (lightweight direct client)
+# Unstructured search using the native DDG client (matches your separate space)
 from duckduckgo_search import DDGS
 
 
@@ -239,7 +235,7 @@ def _format_markdown(
     return "\n\n".join(lines).strip()
 
 
-def extract_relevant(  # <-- MCP tool #1
+def extract_relevant(  # <-- MCP tool #1 (Fetch)
     url: str,
     verbosity: str = "Standard",
     include_metadata: bool = True,
@@ -303,11 +299,11 @@ def extract_relevant(  # <-- MCP tool #1
     return md or "No content could be extracted."
 
 
-# ========================================
-# Websearch (Structured): DuckDuckGo (JSON)
-# ========================================
+# ==========================
+# Websearch: DuckDuckGo tool
+# ==========================
 
-def web_search(  # <-- MCP tool #2
+def web_search(  # <-- MCP tool #2 (Structured DDG)
     input_query: str,
     max_results: int = 5,
 ) -> List[Dict[Literal["snippet", "title", "link"], str]]:
@@ -325,69 +321,21 @@ def web_search(  # <-- MCP tool #2
     return results
 
 
-# ===================================================
-# DDG (Unstructured): compact plain-text, low tokens
-# ===================================================
+# ========================================
+# Unstructured DDG: raw list into Textbox
+# ========================================
 
-def web_search_unstructured(  # <-- MCP tool #3
-    input_query: str,
-    max_results: int = 5,
-    style: Literal["urls", "titles+urls", "titles+urls+snippets"] = "titles+urls",
-    snippet_max_chars: int = 160,
-) -> str:
+def ddg_unstructured(  # <-- MCP tool #3 (Unstructured DDG)
+    query: str,
+) -> list[dict]:
     """
-    (layman) A lightweight DDG search that returns a plain-text list.
-    - Fewer tokens than JSON; great for quick scanning or piping into LLM prompts.
-    - 'style' controls how much text we include per line.
+    (layman) Native DDG client. Returns a plain list[dict] — exactly like your separate space.
     """
-    if not input_query or not input_query.strip():
-        return ""
-
-    # (layman) Run the search using the lightweight DDG client
+    if not query or not query.strip():
+        return []
     with DDGS() as ddgs:
-        results = list(ddgs.text(input_query, max_results=max_results))
-
-    # (layman) Normalize fields because DDG library keys can vary by version
-    lines: List[str] = []
-    for r in results:
-        title = (r.get("title") or "").strip()
-        url = (r.get("href") or r.get("link") or r.get("url") or "").strip()
-        snippet = (r.get("body") or r.get("snippet") or "").strip()
-
-        # (layman) Truncate snippet to keep output tight
-        if snippet_max_chars and len(snippet) > snippet_max_chars:
-            snippet = snippet[:snippet_max_chars - 1].rstrip() + "…"
-
-        # (layman) Build each line according to the chosen style
-        if style == "urls":
-            if url:
-                lines.append(url)
-        elif style == "titles+urls":
-            if title and url:
-                lines.append(f"{title} — {url}")
-            elif url:
-                lines.append(url)
-            elif title:
-                lines.append(title)
-        else:  # titles+urls+snippets
-            if title and url and snippet:
-                lines.append(f"{title} — {url}\n  {snippet}")
-            elif title and url:
-                lines.append(f"{title} — {url}")
-            elif url:
-                # (layman) If only URL is available, still show it
-                if snippet:
-                    lines.append(f"{url}\n  {snippet}")
-                else:
-                    lines.append(url)
-            elif title:
-                if snippet:
-                    lines.append(f"{title}\n  {snippet}")
-                else:
-                    lines.append(title)
-
-    # (layman) Join lines with newlines to form a compact text block
-    return "\n".join(lines).strip()
+        results = ddgs.text(query, max_results=5)
+    return results
 
 
 # =====================
@@ -413,7 +361,7 @@ fetch_interface = gr.Interface(
     theme="Nymbo/Nymbo_Theme",
 )
 
-# --- Websearch tab (structured JSON) ---
+# --- Websearch tab (structured DDG via LangChain) ---
 websearch_interface = gr.Interface(
     fn=web_search,  # (layman) connect the function to the UI
     inputs=[
@@ -421,41 +369,30 @@ websearch_interface = gr.Interface(
         gr.Slider(minimum=1, maximum=20, value=5, step=1, label="Max results"),
     ],
     outputs=gr.JSON(label="Search results"),
-    title="Websearch — DuckDuckGo (JSON)",
-    description="Search the web using DuckDuckGo; returns snippet, title, and link as JSON.",
+    title="Websearch — DuckDuckGo (Structured)",
+    description="Search the web using DuckDuckGo; returns snippet, title, and link.",
     allow_flagging="never",
     theme="Nymbo/Nymbo_Theme",
 )
 
-# --- DDG (Unstructured) tab (plain text, low tokens) ---
+# --- Unstructured DDG tab (matches your separate app’s output) ---
 unstructured_interface = gr.Interface(
-    fn=web_search_unstructured,  # (layman) connect the function to the UI
-    inputs=[
-        gr.Textbox(value="", label="Search query", placeholder="concise keywords"),
-        gr.Slider(minimum=1, maximum=20, value=5, step=1, label="Max results"),
-        gr.Dropdown(
-            label="Output style",
-            choices=["urls", "titles+urls", "titles+urls+snippets"],
-            value="titles+urls",
-            info="Plain text list; choose how much detail to include."
-        ),
-        gr.Slider(
-            minimum=40, maximum=400, value=160, step=10,
-            label="Snippet max chars",
-            info="Truncate snippet length to keep token usage low."
-        ),
-    ],
-    outputs=gr.Textbox(label="Results (plain text)", interactive=False),
-    title="DDG — Unstructured (Compact)",
-    description="Outputs a plain-text list (great for low-token prompts).",
+    fn=ddg_unstructured,                                       # (layman) raw DDG function
+    inputs=gr.Textbox(label="Enter Search Query"),             # (layman) same single input
+    outputs=gr.Textbox(label="Results", interactive=False),    # (layman) Textbox showing str(list[dict])
+    title="Unstructured DDG (Raw List)",                       # (layman) clear label
+    description="Returns the raw list of results (list[dict]) shown as text.",  # (layman) behavior note
     allow_flagging="never",
     theme="Nymbo/Nymbo_Theme",
+    submit_btn="Search",                                       # (layman) match your original button label
 )
 
-# --- Combine all three into a single app with tabs ---
+# --- Combine all into a single app with tabs ---
 demo = gr.TabbedInterface(
     interface_list=[fetch_interface, websearch_interface, unstructured_interface],
-    tab_names=["Fetch", "Websearch", "DDG (Unstructured)"],
+    tab_names=["Fetch", "Websearch", "Unstructured DDG"],
+    title="Web MCP — Fetch + Websearch + Unstructured DDG",
+    theme="Nymbo/Nymbo_Theme",
 )
 
 # Launch the UI and expose all functions as MCP tools in one server