Deploy Gradio app with multiple files

app.py

@@ -0,0 +1,56 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+from src.chat.handler import chat
+from config import DESCRIPTION
+import gradio as gr
+
+with gr.Blocks(fill_height=True, fill_width=True) as app:
+    with gr.Sidebar(): 
+        gr.HTML(DESCRIPTION)
+    
+    gr.ChatInterface(
+        fn=chat,
+        chatbot=gr.Chatbot(
+            label="SearchGPT | V3",
+            type="messages",
+            show_copy_button=True,
+            scale=1
+        ),
+        type="messages",
+        multimodal=True,
+        flagging_mode="manual",
+        flagging_dir="/app",
+        examples=[
+            ["Introduce yourself fully without withholding anything"],
+            ["Give me a short introduction to large language model"],
+            ["Open this link https://huggingface.co/spaces?sort=trending and check what is currently trending?"],
+            ["Find information about UltimaX Intelligence"],
+            ["DeepSeek has just released DeepSeek V3.2, can you find out more?"],
+            ["Find information for me about SearchGPT by umint and directly compare it with ChatGPT Search and Perplexity"],
+            ["Please find information online regarding the current trends for this month"],
+            ["Find information related to the dangers of AI addiction, including real-life examples"],
+            ["Search for images related to artificial intelligence"],
+            [{"text": "Find similar themes online (using web search) as shown in this image",
+              "files": ["assets/images/ai-generated.png"]}]
+        ],
+        cache_examples=False,
+        textbox=gr.MultimodalTextbox(
+            file_types=["image"],
+            placeholder="Ask SearchGPT anything…",
+            stop_btn=True
+        ),
+        show_api=False
+    )
+
+app.queue(
+  max_size=1,
+  default_concurrency_limit=1
+).launch(
+  server_name="0.0.0.0",
+  pwa=True,
+  max_file_size="1mb",
+  mcp_server=True
+)

config.py

@@ -0,0 +1,85 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import os
+
+ENDPOINT = os.getenv("OPENAI_API_BASE_URL")  # /v1/chat/completions
+API_KEY  = os.getenv("OPENAI_API_KEY")
+MODEL    = "openai/gpt-4o-mini"
+STREAM   = True
+
+RETRY    = 10  # max retries for api request
+
+# See the endpoint list at https://searx.space
+# Public instances do not support JSON. 
+# You will need to modify the main logic to use HTML instead. 
+# Please refer to the SearchGPT 1.0 version for guidance.
+# https://huggingface.co/spaces/umint/searchgpt/blob/0ceb431c97449f214fe952ca356d6f79f0d10983/src/engine/browser_engine.py#L34
+SEARXNG  = "https://umint-searxng.hf.space/search"
+FORMAT   = "json"  # Do not use this when using public instances (doesn't support). See src/tools/workflows/web_search.py#21
+
+READER   = "https://r.jina.ai/"
+
+TIMEOUT  = 60  # 1 minute | for tools
+
+AIOHTTP  = {
+    "use_dns_cache": True,
+    "ttl_dns_cache": 300,
+    "limit": 100,
+    "limit_per_host": 30,
+    "enable_cleanup_closed": True
+}
+
+HEADERS  = {
+    "User-Agent": (
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+        "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+    ),
+    "Accept": (
+        "text/html,application/xhtml+xml,application/xml;q=0.9,"
+        "application/json,image/*,*/*;q=0.8"
+    ), 
+    "Accept-Encoding": "gzip, deflate, br",
+    "DNT": "1",
+    "Upgrade-Insecure-Requests": "1",
+    "Cache-Control": "no-cache, no-store, no-transform, must-revalidate, private",
+    "Pragma": "no-cache",
+    "Sec-Fetch-Dest": "document",
+    "Sec-Fetch-Mode": "navigate",
+    "Sec-Fetch-Site": "cross-site",
+    "Sec-Fetch-User": "?1"
+}
+
+REMINDERS = """
+<system>
+
+1. Collect all URLs, hyperlinks, references, and citations mentioned in the content.
+
+2. Include all the source references or source links or source URLs using HTML format:
+   `<a href='source_link' target='_blank'>source_name_title_or_article</a>`.
+
+</system>
+"""
+
+DESCRIPTION = """
+<h2>Hi there,</h2>
+<p>Welcome to <b>SearchGPT</b> V3!</p><br>
+<p>Faster, smarter, and built for a seamless search experience.</p><br>
+<p>Enjoy private and tracker free searching powered by 
+  <a href="https://umint-searxng.hf.space" target="_blank">SearXNG</a> and GPT-4o Mini.
+</p><br>
+<p>This is a dedicated version separate from the 
+  <a href="https://umint-openwebui.hf.space" target="_blank">main spaces</a> and designed specifically for public use.
+</p><br>
+<p>Interested in exploring the <b>limited models</b> available in the 
+  <a href="https://umint-openwebui.hf.space" target="_blank">main spaces</a>?
+</p>
+<p><br>
+  <a href="https://huggingface.co/spaces/umint/ai/discussions/55" target="_blank">Click here</a> to discover them now!
+</p><br>
+<p><b>Like this project?</b> Feel free to buy me a 
+  <a href="https://ko-fi.com/hadad" target="_blank">coffee</a>.
+</p>
+"""  # Gradio

requirements.txt

@@ -0,0 +1,4 @@
+gradio
+requests
+Pillow
+numpy

src/api/client.py

@@ -0,0 +1,71 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import aiohttp
+import json
+from config import (
+    ENDPOINT,
+    API_KEY,
+    MODEL,
+    STREAM,
+    AIOHTTP,
+    RETRY
+)
+from ..tools.mapping import TOOLS
+
+async def client(messages):
+    async with aiohttp.ClientSession(
+        connector=aiohttp.TCPConnector(**AIOHTTP),
+        headers={
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {API_KEY}"
+        }
+    ) as session:
+        for attempt in range(RETRY):
+            async with session.post(
+                ENDPOINT,
+                json={
+                    "model": MODEL,
+                    "messages": messages,
+                    "tools": TOOLS,
+                    "tool_choice": "auto",
+                    "stream": STREAM
+                }
+            ) as response:
+                if response.status != 200:
+                    if attempt == RETRY - 1:
+                        error_message = await response.text()
+                        raise Exception(f"Error ({response.status}): {error_message}")
+                    continue
+                
+                buffer = ""
+                
+                async for parts in response.content.iter_any():
+                    if not parts:
+                        continue
+                    
+                    buffer += parts.decode('utf-8')
+                    
+                    while '\n' in buffer:
+                        line, buffer = buffer.split('\n', 1)
+                        data = line.strip()
+                        
+                        if not data:
+                            continue
+                        
+                        if data.startswith("data: "):
+                            data = data[6:]
+                        
+                        if data == "[DONE]":
+                            return
+                        
+                        if data:
+                            try:
+                                chunk = json.loads(data)
+                                yield chunk
+                            except json.JSONDecodeError:
+                                continue
+                
+                return

src/chat/handler.py

@@ -0,0 +1,117 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import json
+from ...config import REMINDERS
+from ..api.client import client
+from ..tools.executor import tool_execution
+from ..utils.time import get_current_time
+from ..media.message_adapter import adapt_message_format
+
+async def chat(user_message, history):
+    if not user_message or (
+        isinstance(user_message, dict) and not (user_message.get("text") or user_message.get("files"))
+    ) or (isinstance(user_message, str) and not user_message.strip()):
+        yield []
+        return
+    
+    messages = []
+    
+    messages.append({"role": "system", "content": f"Today is: {get_current_time()}\n\n{REMINDERS}"})
+    
+    for history_entry in history:
+        entry_role = history_entry.get("role")
+        entry_content = history_entry.get("content")
+        
+        if entry_role == "user":
+            adapted_content = await adapt_message_format(entry_content)
+            messages.append({"role": "user", "content": adapted_content})
+        elif entry_role == "assistant":
+            messages.append({"role": "assistant", "content": entry_content})
+    
+    adapted_user_message = await adapt_message_format(user_message)
+    
+    messages.append({"role": "user", "content": adapted_user_message})
+    
+    normal_response = ""
+    
+    while True:
+        tools_mapping = []
+        final_response = ""
+        finish_reason = None
+        
+        async for chunk in client(messages):
+            if chunk.get("choices") and len(chunk["choices"]) > 0:
+                choice = chunk["choices"][0]
+                delta = choice.get("delta", {})
+                
+                if choice.get("finish_reason"):
+                    finish_reason = choice["finish_reason"]
+                
+                if delta.get("content") is not None:
+                    final_response += delta["content"]
+                    normal_response += delta["content"]
+                    yield normal_response
+                
+                if delta.get("tool_calls"):
+                    for tool_delta in delta["tool_calls"]:
+                        tool_index = tool_delta.get("index", 0)
+                        
+                        while len(tools_mapping) <= tool_index:
+                            tools_mapping.append({
+                                "id": "",
+                                "type": "function",
+                                "function": {
+                                    "name": "",
+                                    "arguments": ""
+                                }
+                            })
+                        
+                        if tool_delta.get("id"):
+                            tools_mapping[tool_index]["id"] = tool_delta["id"]
+                        
+                        if tool_delta.get("function"):
+                            if tool_delta["function"].get("name"):
+                                tools_mapping[tool_index]["function"]["name"] = tool_delta["function"]["name"]
+                            
+                            if tool_delta["function"].get("arguments"):
+                                tools_mapping[tool_index]["function"]["arguments"] += tool_delta["function"]["arguments"]
+        
+        if tools_mapping:
+            messages.append({
+                "role": "assistant",
+                "content": final_response if final_response else None,
+                "tool_calls": tools_mapping
+            })
+            
+            for tool_call in tools_mapping:
+                try:
+                    tool_name = tool_call["function"]["name"]
+                    tool_args = json.loads(tool_call["function"]["arguments"])
+                    
+                    tool_result = await tool_execution(tool_name, tool_args)
+                    
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call["id"],
+                        "content": tool_result
+                    })
+                except Exception as error:
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call["id"],
+                        "content": f"Error: {str(error)}"
+                    })
+            
+            continue
+        
+        if final_response:
+            messages.append({"role": "assistant", "content": final_response})
+            break
+        
+        if finish_reason:
+            break
+    
+    yield normal_response

src/media/bytes_loader.py

@@ -0,0 +1,8 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+async def load_file_bytes(file_path):
+    with open(file_path, 'rb') as stream:
+        return stream.read()

src/media/content_assembler.py

@@ -0,0 +1,23 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+async def assemble_content_parts(text_value, url_collection):
+    parts = []
+    
+    if text_value:
+        parts.append({
+            "type": "text",
+            "text": text_value
+        })
+    
+    for url_item in url_collection:
+        parts.append({
+            "type": "image_url",
+            "image_url": {
+                "url": url_item
+            }
+        })
+    
+    return parts

src/media/encoding_converter.py

@@ -0,0 +1,10 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import base64
+
+async def convert_to_base64(binary_data):
+    encoded = base64.b64encode(binary_data)
+    return encoded.decode('utf-8')

src/media/filetype_resolver.py

@@ -0,0 +1,10 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import mimetypes
+
+async def resolve_filetype(file_path):
+    detected_type, _ = mimetypes.guess_type(file_path)
+    return detected_type if detected_type else "image/jpeg"

src/media/message_adapter.py

@@ -0,0 +1,45 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+from .bytes_loader import load_file_bytes
+from .encoding_converter import convert_to_base64
+from .filetype_resolver import resolve_filetype
+from .url_composer import compose_data_url
+from .content_assembler import assemble_content_parts
+
+async def adapt_message_format(incoming_message):
+    if isinstance(incoming_message, str):
+        return incoming_message
+    
+    if not isinstance(incoming_message, dict):
+        return str(incoming_message)
+    
+    text_value = incoming_message.get("text", "")
+    attached_files = incoming_message.get("files", [])
+    
+    if not attached_files:
+        return text_value if text_value else ""
+    
+    url_collection = []
+    
+    for file_entry in attached_files:
+        file_location = file_entry if isinstance(file_entry, str) else file_entry.get("path")
+        
+        if not file_location:
+            continue
+        
+        binary_data = await load_file_bytes(file_location)
+        encoded_string = await convert_to_base64(binary_data)
+        file_type = await resolve_filetype(file_location)
+        url_item = await compose_data_url(encoded_string, file_type)
+        
+        url_collection.append(url_item)
+    
+    if not url_collection:
+        return text_value if text_value else ""
+    
+    content_parts = await assemble_content_parts(text_value, url_collection)
+    
+    return content_parts

src/media/url_composer.py

@@ -0,0 +1,7 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+async def compose_data_url(encoded_string, file_type):
+    return f"data:{file_type};base64,{encoded_string}"

src/tools/executor.py

@@ -0,0 +1,17 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+from .workflows.open_link import open_link
+from .workflows.web_search import web_search
+
+async def tool_execution(tool_name, tool_arguments):
+    if tool_name == "open_link":
+        return await open_link(tool_arguments["url"])
+        
+    elif tool_name == "web_search":
+        return await web_search(tool_arguments["query"])
+
+    else:
+        return f"Unknown tool: {tool_name}"

src/tools/mapping.py

@@ -0,0 +1,41 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "web_search",
+            "description": "Search the web using SearXNG and return results",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "The search query"
+                    }
+                },
+                "required": ["query"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "open_link",
+            "description": "Open a web page using a URL, link, or hyperlink and extract its main content",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "url": {
+                        "type": "string",
+                        "description": "The URL, link, or hyperlink of the web page to open and read"
+                    }
+                },
+                "required": ["url"]
+            }
+        }
+    }
+]

src/tools/workflows/open_link.py

@@ -0,0 +1,27 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import aiohttp
+from config import (
+    READER,
+    TIMEOUT,
+    AIOHTTP,
+    HEADERS,
+    REMINDERS
+)
+
+async def open_link(url):
+    try:
+        async with aiohttp.ClientSession(
+            connector=aiohttp.TCPConnector(**AIOHTTP),
+            timeout=aiohttp.ClientTimeout(total=TIMEOUT),
+            headers=HEADERS
+        ) as session:
+            async with session.post(READER, data={"url": url}) as response:
+                response.raise_for_status()
+                content = await response.text()
+        return content + "\n\n\n" + REMINDERS
+    except Exception as error:
+        return f"Error reading URL: {str(error)}"

src/tools/workflows/web_search.py

@@ -0,0 +1,28 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import aiohttp
+from config import (
+    SEARXNG,
+    FORMAT,
+    TIMEOUT,
+    AIOHTTP,
+    HEADERS,
+    REMINDERS
+)
+
+async def web_search(query):
+    try:
+        async with aiohttp.ClientSession(
+            connector=aiohttp.TCPConnector(**AIOHTTP),
+            timeout=aiohttp.ClientTimeout(total=TIMEOUT),
+            headers=HEADERS
+        ) as session:
+            async with session.get(f"{SEARXNG}?q={query}&format={FORMAT}") as response:
+                response.raise_for_status()
+                content = await response.text()
+        return content + "\n\n\n" + REMINDERS
+    except Exception as error:
+        return f"Error during web search: {str(error)}"

src/utils/time.py

@@ -0,0 +1,11 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+from datetime import datetime, timezone
+
+def get_current_time() -> str:
+    return datetime.now(timezone.utc).strftime(
+        "%H:%M %Z. %A, %d %B %Y."
+    )