Update app.py

app.py

@@ -1,220 +1,43 @@
-import gradio as gr
 import os
-import asyncio
-from typing import List
-from google import genai
-from google.genai import types
-from mcp import ClientSession, StdioServerParameters
-from mcp.client.stdio import stdio_client
-
-# MCP-Server Konfiguration (ohne ungültigen Transport-Parameter)
-server_params = StdioServerParameters(
-    command="npx",
-    args=[
-        "mcp-remote",
-        "https://mgokg-db-timetable-api.hf.space/gradio_api/mcp/"
-    ]
-)
-
-async def generate(input_text):
-    try:
-        client = genai.Client(api_key=os.environ.get("GEMINI_API_KEY"))
-    except Exception as e:
-        return f"Fehler bei der Initialisierung: {e}", ""
-
-    model = "gemini-flash-latest"
-
-    try:
-        # MCP-Session aufbauen
-        async with stdio_client(server_params) as (read, write):
-            async with ClientSession(read, write) as session:
-                await session.initialize()
-                
-                # MCP-Tools abrufen
-                mcp_tools_data = await session.list_tools()
-                
-                # Tools in Gemini-kompatibles Format konvertieren
-                mcp_declarations = []
-                for tool in mcp_tools_data.tools:
-                    # Sicherstellen, dass inputSchema korrekt formatiert ist
-                    schema = tool.inputSchema if tool.inputSchema else {
-                        "type": "object",
-                        "properties": {},
-                        "required": []
-                    }
-                    
-                    mcp_declarations.append(
-                        types.FunctionDeclaration(
-                            name=tool.name,
-                            description=tool.description or "MCP Tool",
-                            parameters=schema
-                        )
-                    )
-
-                # Tools kombinieren: Google Search + MCP Tools
-                tools = [types.Tool(function_declarations=mcp_declarations)]
-            
-
-                contents = [types.Content(
-                    role="user", 
-                    parts=[types.Part.from_text(text=input_text)]
-                )]
-                
-                # Erster API-Aufruf
-                response = await client.aio.models.generate_content(
-                    model=model,
-                    contents=contents,
-                    config=types.GenerateContentConfig(
-                        tools=tools,
-                        temperature=0.4
-                    )
-                )
-                
-                # Agentic Loop für Tool-Calls
-                turn_count = 0
-                max_turns = 5
-                
-                while hasattr(response.candidates[0].content, 'parts') and turn_count < max_turns:
-                    function_calls = [
-                        part for part in response.candidates[0].content.parts 
-                        if hasattr(part, 'function_call') and part.function_call
-                    ]
-                    
-                    if not function_calls:
-                        break
-                    
-                    turn_count += 1
-                    contents.append(response.candidates[0].content)
-                    tool_responses = []
-                    
-                    for part in function_calls:
-                        fc = part.function_call
-                        try:
-                            # MCP-Tool ausführen
-                            tool_result = await session.call_tool(fc.name, dict(fc.args))
-                            
-                            # Ergebnis formatieren
-                            if tool_result.isError:
-                                result_text = f"Error: {tool_result.content[0].text if tool_result.content else 'Unknown error'}"
-                            else:
-                                result_text = tool_result.content[0].text if tool_result.content else "No result"
-                            
-                            tool_responses.append(
-                                types.Part.from_function_response(
-                                    name=fc.name,
-                                    response={"result": result_text}
-                                )
-                            )
-                        except Exception as e:
-                            tool_responses.append(
-                                types.Part.from_function_response(
-                                    name=fc.name,
-                                    response={"error": str(e)}
-                                )
-                            )
-
-                    contents.append(types.Content(role="function", parts=tool_responses))
-                    
-                    # Nächster API-Aufruf
-                    response = await client.aio.models.generate_content(
-                        model=model,
-                        contents=contents,
-                        config=types.GenerateContentConfig(tools=tools, temperature=0.4)
-                    )
-
-                return response.text, ""
-    
-    except Exception as e:
-        return f"Fehler während der Verarbeitung: {str(e)}", ""
-
-# Gradio UI Wrapper
-def ui_wrapper(input_text):
-    try:
-        return asyncio.run(generate(input_text))
-    except Exception as e:
-        return f"UI Fehler: {str(e)}", ""
-
-if __name__ == '__main__':
-    with gr.Blocks() as demo:
-        gr.Markdown("# Gemini 2.0 Flash + Google Search + DB Timetable (MCP)")
-        output_textbox = gr.Markdown()
-        input_textbox = gr.Textbox(
-            lines=3, 
-            label="Anfrage", 
-            placeholder="z.B. Wie komme ich von Berlin nach Hamburg?"
-        )
-        submit_button = gr.Button("Senden")
-        
-        submit_button.click(
-            fn=ui_wrapper,
-            inputs=input_textbox,
-            outputs=[output_textbox, input_textbox]
-        )
-    
-    demo.launch(show_error=True)
-
-
-import base64
 import gradio as gr
-import os
-import json
 from google import genai
 from google.genai import types
-from gradio_client import Client
-
 
-def generate(input_text):
-    try:
-        client = genai.Client(
-            api_key=os.environ.get("GEMINI_API_KEY"),
-        )
-    except Exception as e:
-        return f"Error initializing client: {e}.  Make sure GEMINI_API_KEY is set."
+# Client initialisieren
+client = genai.Client(api_key=os.environ.get("GEMINI_API_KEY"))
 
-    model = "gemini-2.5-flash-lite"
+def gemini_chat(prompt, history):
+    # Vorbereitung der Inhalte
     contents = [
         types.Content(
             role="user",
-            parts=[
-                types.Part.from_text(text=f"{input_text}"),
-            ],
+            parts=[types.Part.from_text(text=prompt)],
         ),
     ]
-    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",
-    )
-
+    
+    # Konfiguration mit Google Search Tool
+    tools = [types.Tool(google_search=types.GoogleSearch())]
+    config = types.GenerateContentConfig(tools=tools)
 
     response_text = ""
-    try:
-      for chunk in client.models.generate_content_stream(
-          model=model,
-          contents=contents,
-          config=generate_content_config,
-      ):
-          response_text += chunk.text
-    except Exception as 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__':
+    
+    # Streaming-Generator für Gradio
+    for chunk in client.models.generate_content_stream(
+        model="gemini-2.0-flash-001", # Aktuellste Version
+        contents=contents,
+        config=config,
+    ):
+        if chunk.text:
+            response_text += chunk.text
+            yield response_text
+
+# Gradio Interface Setup
+demo = gr.ChatInterface(
+    fn=gemini_chat,
+    title="Gemini Flash mit Google Search",
+    description="Gib eine Frage ein, und Gemini nutzt die Google Suche für aktuelle Antworten.",
+    type="messages"
+)
 
-    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)
+if __name__ == "__main__":
+    demo.launch()