Update app.py

app.py

@@ -1,179 +1,65 @@
+import base64
 import gradio as gr
 import os
-import asyncio
 import json
 from google import genai
 from google.genai import types
+from gradio_client import Client
 
-# MCP Imports
-from mcp import ClientSession, StdioServerParameters
-from mcp.client.sse import sse_client
-from mcp.types import CallToolResult
 
-# --- Konfiguration ---
-MCP_SERVER_URL = "https://mgokg-db-timetable-api.hf.space/gradio_api/mcp/"
-# Stelle sicher, dass du einen validen Model-Namen hast (z.B. gemini-2.0-flash-exp oder gemini-1.5-flash)
-MODEL_ID = "gemini-2.0-flash-exp" 
-
-async def generate_response(user_input, history):
-    """
-    Core Logic: Verbindet MCP, Google Search und Gemini.
-    """
-    # 1. Gemini Client initialisieren
+def generate(input_text):
     try:
-        client = genai.Client(api_key=os.environ.get("GEMINI_API_KEY"))
+        client = genai.Client(
+            api_key=os.environ.get("GEMINI_API_KEY"),
+        )
     except Exception as e:
-        yield f"Error initializing Gemini client: {e}. Make sure GEMINI_API_KEY is set."
-        return
-
-    # 2. Verbindung zum MCP Server aufbauen (SSE)
+        return f"Error initializing client: {e}.  Make sure GEMINI_API_KEY is set."
+
+    model = "gemini-flash-latest"
+    contents = [
+        types.Content(
+            role="user",
+            parts=[
+                types.Part.from_text(text=f"{input_text}"),
+            ],
+        ),
+    ]
+    tools = [
+        types.Tool(google_search=types.GoogleSearch()),
+    ]
+    generate_content_config = types.GenerateContentConfig(
+        temperature=0.4,
+        thinking_config = types.ThinkingConfig(
+            thinking_budget=0,
+        ),
+        tools=tools,
+        response_mime_type="text/plain",
+    )
+
+
+    response_text = ""
     try:
-        async with sse_client(url=MCP_SERVER_URL) as streams:
-            async with ClientSession(streams.read, streams.write) as session:
-                await session.initialize()
-                
-                # Tools vom MCP Server abrufen
-                mcp_list = await session.list_tools()
-                
-                # Tools für Gemini konvertieren
-                gemini_tools_declarations = []
-                for tool in mcp_list.tools:
-                    desc = tool.description or "Tool to query DB (Deutsche Bahn) train timetables."
-                    gemini_tools_declarations.append(
-                        types.FunctionDeclaration(
-                            name=tool.name,
-                            description=desc,
-                            parameters=tool.inputSchema
-                        )
-                    )
-
-                # Tools zusammenstellen (Google Search + MCP)
-                tools_config = [
-                    types.Tool(google_search=types.GoogleSearch()),
-                    types.Tool(function_declarations=gemini_tools_declarations)
-                ]
-
-                # Config
-                generate_content_config = types.GenerateContentConfig(
-                    temperature=0.4,
-                    tools=tools_config,
-                    system_instruction="You are a helpful assistant. Use 'db_timetable_api_ui_wrapper' for German train connections. Use Google Search for other current info.",
-                    response_mime_type="text/plain",
-                )
-
-                # History für Gemini aufbereiten
-                # Wir nehmen hier vereinfacht nur den aktuellen User-Input, 
-                # für echte Multi-Turn-Gespräche müsste man 'history' parsen.
-                contents = [
-                    types.Content(
-                        role="user",
-                        parts=[types.Part.from_text(text=user_input)],
-                    ),
-                ]
-
-                # --- Loop für Tool Calls ---
-                while True:
-                    response_stream = await client.models.generate_content_stream(
-                        model=MODEL_ID,
-                        contents=contents,
-                        config=generate_content_config,
-                    )
-
-                    full_text = ""
-                    function_calls = []
-                    
-                    async for chunk in response_stream:
-                        if chunk.text:
-                            full_text += chunk.text
-                            yield full_text # Live-Update des Textes
-                        
-                        if chunk.function_calls:
-                            for fc in chunk.function_calls:
-                                function_calls.append(fc)
-
-                    if not function_calls:
-                        break # Keine Tools mehr, wir sind fertig
-                    
-                    # Tool Calls verarbeiten
-                    # 1. Modell-Antwort zur History hinzufügen (damit es weiß, dass es gefragt hat)
-                    contents.append(types.Content(
-                        role="model",
-                        parts=[types.Part.from_function_call(name=fc.name, args=fc.args) for fc in function_calls]
-                    ))
-
-                    # 2. Tools ausführen
-                    for fc in function_calls:
-                        yield f"\n\n*Rufe MCP Tool auf: {fc.name}...*\n"
-                        
-                        try:
-                            result = await session.call_tool(name=fc.name, arguments=fc.args)
-                            
-                            # Ergebnis extrahieren
-                            tool_output = ""
-                            if result.content:
-                                for item in result.content:
-                                    if item.type == "text":
-                                        tool_output += item.text
-                            
-                            # Ergebnis zur History
-                            contents.append(types.Content(
-                                role="tool",
-                                parts=[types.Part.from_function_response(
-                                    name=fc.name,
-                                    response={"result": tool_output}
-                                )]
-                            ))
-                        except Exception as e:
-                            contents.append(types.Content(
-                                role="tool",
-                                parts=[types.Part.from_function_response(
-                                    name=fc.name,
-                                    response={"error": str(e)}
-                                )]
-                            ))
-                    
-                    # Schleife läuft weiter -> Gemini bekommt Tool-Ergebnisse und antwortet neu
-
+      for chunk in client.models.generate_content_stream(
+          model=model,
+          contents=contents,
+          config=generate_content_config,
+      ):
+          response_text += chunk.text
     except Exception as e:
-        yield f"Ein Fehler ist aufgetreten: {e}"
-
+        return f"Error during generation: {e}"
+    data = response_text  
+    #data = clean_json_string(response_text)
+    data = data[:-1]
+    return response_text, ""
+   
 
 if __name__ == '__main__':
-    with gr.Blocks() as demo:
-        gr.Markdown("# Gemini 2.0 Flash + Websearch + MCP (DB)")
-        
-        # Chat-Fenster
-        chatbot = gr.Chatbot(height=500, type="messages")
-        
-        # Eingabebereich
-        with gr.Row():
-            msg = gr.Textbox(
-                scale=4, 
-                show_label=False, 
-                placeholder="Nachricht eingeben (z.B. Zug von Berlin nach München)...",
-                container=False
-            )
-            submit_btn = gr.Button("Send", scale=1, variant="primary")
-
-        # Hilfsfunktionen für Gradio Event-Handling
-        async def user_turn(user_message, history):
-            return "", history + [{"role": "user", "content": user_message}]
 
-        async def bot_turn(history):
-            user_message = history[-1]["content"]
-            history.append({"role": "assistant", "content": ""})
-            
-            async for chunk in generate_response(user_message, history):
-                history[-1]["content"] = chunk
-                yield history
-
-        # Events: Sowohl Enter (msg.submit) als auch Klick (submit_btn.click) lösen das Gleiche aus
-        msg.submit(user_turn, [msg, chatbot], [msg, chatbot], queue=False).then(
-            bot_turn, [chatbot], [chatbot]
-        )
-        
-        submit_btn.click(user_turn, [msg, chatbot], [msg, chatbot], queue=False).then(
-            bot_turn, [chatbot], [chatbot]
-        )
+    with gr.Blocks() as demo:
+        title=gr.Markdown("# Gemini 2.0 Flash + Websearch")
+        output_textbox = gr.Markdown()
+        input_textbox = gr.Textbox(lines=3, label="", placeholder="Enter message here...")
+        submit_button = gr.Button("send")
+        submit_button.click(fn=generate,inputs=input_textbox,outputs=[output_textbox, input_textbox])
+    demo.launch(show_error=True)
 
-    demo.launch(show_error=True)