Update app.py

app.py

@@ -7,16 +7,12 @@ from google.genai import types
 from mcp import ClientSession, StdioServerParameters
 from mcp.client.stdio import stdio_client
 
-# 1. Konfiguration des MCP-Servers via STDIO-Bridge
-# FIX: Changed transport from 'streamable-http' to 'http-first' based on error log
+# MCP-Server Konfiguration (ohne ungültigen Transport-Parameter)
 server_params = StdioServerParameters(
     command="npx",
     args=[
-        "-y", # Auto-confirm installation if needed
         "mcp-remote",
-        "https://mgokg-db-timetable-api.hf.space/gradio_api/mcp/",
-        "--transport",
-        "http-first" 
+        "https://mgokg-db-timetable-api.hf.space/gradio_api/mcp/"
     ]
 )
 
@@ -26,96 +22,129 @@ async def generate(input_text):
     except Exception as e:
         return f"Fehler bei der Initialisierung: {e}", ""
 
-    model = "gemini-2.5-flash" 
-
-    # 2. Aufbau der MCP-Session
-    # Note: This context manager keeps the connection open only during the generation
-    async with stdio_client(server_params) as (read, write):
-        async with ClientSession(read, write) as session:
-            await session.initialize()
-            
-            # MCP-Tools abrufen und in Gemini-Format konvertieren
-            mcp_tools_data = await session.list_tools()
-            mcp_declarations = [
-                {
-                    "name": tool.name,
-                    "description": tool.description or "Ruft Zugverbindungen ab.",
-                    "parameters": tool.inputSchema,
-                }
-                for tool in mcp_tools_data.tools
-            ]
-
-            # 3. Kombination der Tools
-            # Using function_declarations disables Automatic Function Calling (AFC),
-            # which is what we want because we handle the loop manually below.
-            tools = [
-                types.Tool(google_search=types.GoogleSearch()),
-                types.Tool(function_declarations=mcp_declarations)
-            ]
-
-            contents = [types.Content(role="user", parts=[types.Part.from_text(text=input_text)])]
-            
-            # Erster Aufruf an das Modell
-            response = await client.aio.models.generate_content(
-                model=model,
-                contents=contents,
-                config=types.GenerateContentConfig(tools=tools, temperature=0.4)
-            )
-            
-            # 4. Agentic Loop: Bearbeitung von Tool-Calls
-            turn_count = 0
-            
-            # Note: response.function_calls is a helper property in the SDK
-            while response.function_calls and turn_count < 5:
-                turn_count += 1
+    model = "gemini-2.0-flash-exp"
+
+    try:
+        # MCP-Session aufbauen
+        async with stdio_client(server_params) as (read, write):
+            async with ClientSession(read, write) as session:
+                await session.initialize()
                 
-                # FIX: response.candidates is a list. Must access index 0.
-                contents.append(response.candidates[0].content)
+                # MCP-Tools abrufen
+                mcp_tools_data = await session.list_tools()
                 
-                tool_responses = []
+                # 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(google_search=types.GoogleSearch())]
                 
-                for fc in response.function_calls:
-                    try:
-                        # Ausführung des MCP-Tools
-                        tool_result = await session.call_tool(fc.name, fc.args)
-                        
-                        # Ergebnis formatieren
-                        # Check if content is a list (standard MCP) or text
-                        if hasattr(tool_result.content, 'text'):
-                             # Some implementations might differ, standardizing to string
-                             result_data = tool_result.content.text
-                        elif isinstance(tool_result.content, list):
-                             result_data = "\n".join([item.text for item in tool_result.content if hasattr(item, 'text')])
-                        else:
-                             result_data = str(tool_result.content)
-
-                        tool_responses.append(types.Part.from_function_response(
-                            name=fc.name, response={"result": result_data}
-                        ))
-                    except Exception as e:
-                        tool_responses.append(types.Part.from_function_response(
-                            name=fc.name, response={"error": str(e)}
-                        ))
-
-                contents.append(types.Content(role="user", parts=tool_responses))
+                if mcp_declarations:
+                    tools.append(types.Tool(function_declarations=mcp_declarations))
+
+                contents = [types.Content(
+                    role="user", 
+                    parts=[types.Part.from_text(text=input_text)]
+                )]
                 
-                # Nächster Modell-Aufruf mit den Tool-Ergebnissen
+                # Erster API-Aufruf
                 response = await client.aio.models.generate_content(
-                    model=model, contents=contents, config=types.GenerateContentConfig(tools=tools)
+                    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)}", ""
 
-            return response.text, ""
-
-# 5. Gradio UI Integration
-# FIX: Made this async and removed asyncio.run() to prevent Event Loop conflicts
-async def ui_wrapper(input_text):
-    return await generate(input_text)
+# 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 + Search + DB Timetable")
+        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?")
+        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(
@@ -123,8 +152,8 @@ if __name__ == '__main__':
             inputs=input_textbox,
             outputs=[output_textbox, input_textbox]
         )
-    demo.launch(show_error=True, ssr_mode=False)
-
+    
+    demo.launch(show_error=True)
 
 """
 import base64