feat: improve route configuration and UI layout - Add empty route option for automatic route selection, Move route dropdown to front, Move Answer section higher up, Update route handling to pass None for auto-selection

CONFIG_GUIDE.md

@@ -0,0 +1,113 @@
+# Minion Brain Chat - LLM Configuration Guide
+
+This application now supports flexible LLM configuration, allowing you to configure language models in multiple ways.
+
+## Features
+
+### 1. Preset Configurations
+The application has built-in preset configurations loaded from `.env` file:
+- **gpt-4o**: GPT-4o Azure configuration
+- **gpt-4o-mini**: GPT-4o-mini Azure configuration  
+- **gpt-4.1**: GPT-4.1 Azure configuration
+- **o4-mini**: O4-mini Azure configuration
+
+### 2. Custom Configuration
+Select "Custom" option to fully customize all LLM parameters:
+- API Type (openai, azure, ollama, groq, etc.)
+- API Key
+- Base URL
+- API Version  
+- Model Name
+- Temperature (0.0-2.0)
+- Max Tokens (100-8000)
+
+### 3. Environment Variable Support
+The application automatically loads configurations from `.env` file. Environment variable format:
+
+```bash
+# GPT-4o Azure Configuration
+GPT_4O_API_TYPE=azure
+GPT_4O_API_KEY=your_api_key_here
+GPT_4O_BASE_URL=https://your-endpoint.openai.azure.com/
+GPT_4O_API_VERSION=2024-06-01
+GPT_4O_TEMPERATURE=0
+GPT_4O_MAX_TOKENS=4000
+GPT_4O_MODEL=gpt-4o
+```
+
+## Usage
+
+### Method 1: Using Preset Configurations
+1. Select a preset configuration from "Preset Model" dropdown (e.g., gpt-4o)
+2. Other fields will automatically populate with corresponding configuration values
+3. Enter your question and submit
+
+### Method 2: Custom Configuration
+1. Select "Custom" from "Preset Model" dropdown
+2. Manually fill in all configuration fields:
+   - API Type: Choose provider type
+   - API Key: Enter your API key
+   - Base URL: Enter API base URL
+   - API Version: Enter API version (required for Azure)
+   - Model: Enter model name
+   - Temperature: Adjust generation randomness
+   - Max Tokens: Set maximum generation length
+3. Enter your question and submit
+
+## Security
+
+- API keys are displayed as `***hidden***` in the interface
+- `.env` file is added to `.gitignore` and won't be committed to version control
+
+## Configuration Examples
+
+### OpenAI Configuration
+```
+API Type: openai
+API Key: sk-your-openai-api-key
+Base URL: https://api.openai.com/v1
+API Version: (leave empty)
+Model: gpt-4
+Temperature: 0.7
+Max Tokens: 4000
+```
+
+### Azure OpenAI Configuration
+```
+API Type: azure
+API Key: your-azure-api-key  
+Base URL: https://your-resource.openai.azure.com/
+API Version: 2024-06-01
+Model: gpt-4
+Temperature: 0.7
+Max Tokens: 4000
+```
+
+### Ollama Local Configuration
+```
+API Type: ollama
+API Key: (leave empty)
+Base URL: http://localhost:11434
+API Version: (leave empty)
+Model: llama2
+Temperature: 0.7
+Max Tokens: 4000
+```
+
+## Troubleshooting
+
+1. **API Key Error**: Check if API key is correct and valid
+2. **Connection Error**: Verify if Base URL is correct
+3. **Permission Error**: Ensure API key has access to the specified model
+4. **Version Error**: For Azure, ensure API Version is correct
+
+## Updating Configuration
+
+To update preset configurations:
+1. Edit the `.env` file
+2. Restart the application to load new configurations
+
+To add new preset configurations:
+1. Add new environment variables in `.env` file
+2. Add new configuration in `get_preset_configs()` function in `app1.py`
+3. Restart the application 

README.md

@@ -5,7 +5,7 @@ colorFrom: yellow
 colorTo: purple
 sdk: gradio
 sdk_version: 5.32.0
-app_file: app.py
+app_file: app1.py
 pinned: false
 license: mit
 short_description: minion running in space

app1.py

@@ -1,6 +1,8 @@
 import gradio as gr
 import asyncio
 import os
+from typing import Dict, Any
+from dotenv import load_dotenv
 
 from minion import config
 from minion.main import LocalPythonEnv
@@ -8,12 +10,113 @@ from minion.main.rpyc_python_env import RpycPythonEnv
 from minion.main.brain import Brain
 from minion.providers import create_llm_provider
 
-# 初始化 brain（只初始化一次，避免每次请求都重建）
-def build_brain():
-    model = "gpt-4.1"
-    llm_config = config.models.get(model)
-    llm = create_llm_provider(llm_config)
-    #python_env = RpycPythonEnv(port=3007)
+# Load .env file
+load_dotenv()
+
+class LLMConfig:
+    def __init__(self, api_type: str, api_key: str, base_url: str, api_version: str, 
+                 model: str, temperature: float = 0.7, max_tokens: int = 4000, 
+                 vision_enabled: bool = False):
+        self.api_type = api_type
+        self.api_key = api_key
+        self.base_url = base_url
+        self.api_version = api_version
+        self.model = model
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.vision_enabled = vision_enabled
+
+def get_preset_configs():
+    """Get preset configurations"""
+    presets = {
+        "gpt-4o": LLMConfig(
+            api_type=os.getenv("GPT_4O_API_TYPE", "azure"),
+            api_key=os.getenv("GPT_4O_API_KEY", ""),
+            base_url=os.getenv("GPT_4O_BASE_URL", ""),
+            api_version=os.getenv("GPT_4O_API_VERSION", "2024-06-01"),
+            model=os.getenv("GPT_4O_MODEL", "gpt-4o"),
+            temperature=float(os.getenv("GPT_4O_TEMPERATURE", "0")),
+            max_tokens=int(os.getenv("GPT_4O_MAX_TOKENS", "4000"))
+        ),
+        "gpt-4o-mini": LLMConfig(
+            api_type=os.getenv("GPT_4O_MINI_API_TYPE", "azure"),
+            api_key=os.getenv("GPT_4O_MINI_API_KEY", ""),
+            base_url=os.getenv("GPT_4O_MINI_BASE_URL", ""),
+            api_version=os.getenv("GPT_4O_MINI_API_VERSION", "2024-06-01"),
+            model=os.getenv("GPT_4O_MINI_MODEL", "gpt-4o-mini"),
+            temperature=float(os.getenv("GPT_4O_MINI_TEMPERATURE", "0.1")),
+            max_tokens=int(os.getenv("GPT_4O_MINI_MAX_TOKENS", "4000"))
+        ),
+        "gpt-4.1": LLMConfig(
+            api_type=os.getenv("GPT_41_API_TYPE", "azure"),
+            api_key=os.getenv("GPT_41_API_KEY", ""),
+            base_url=os.getenv("GPT_41_BASE_URL", ""),
+            api_version=os.getenv("GPT_41_API_VERSION", "2025-03-01-preview"),
+            model=os.getenv("GPT_41_MODEL", "gpt-4.1"),
+            temperature=float(os.getenv("GPT_41_TEMPERATURE", "0.7")),
+            max_tokens=int(os.getenv("GPT_41_MAX_TOKENS", "4000"))
+        ),
+        "o4-mini": LLMConfig(
+            api_type=os.getenv("O4_MINI_API_TYPE", "azure"),
+            api_key=os.getenv("O4_MINI_API_KEY", ""),
+            base_url=os.getenv("O4_MINI_BASE_URL", ""),
+            api_version=os.getenv("O4_MINI_API_VERSION", "2025-03-01-preview"),
+            model=os.getenv("O4_MINI_MODEL", "o4-mini"),
+            temperature=float(os.getenv("O4_MINI_TEMPERATURE", "0.7")),
+            max_tokens=int(os.getenv("O4_MINI_MAX_TOKENS", "4000"))
+        )
+    }
+    return presets
+
+def get_default_config():
+    """Get default configuration"""
+    return LLMConfig(
+        api_type=os.getenv("DEFAULT_API_TYPE", "azure"),
+        api_key=os.getenv("DEFAULT_API_KEY", ""),
+        base_url=os.getenv("DEFAULT_BASE_URL", ""),
+        api_version=os.getenv("DEFAULT_API_VERSION", "2024-06-01"),
+        model=os.getenv("DEFAULT_MODEL", "gpt-4o"),
+        temperature=float(os.getenv("DEFAULT_TEMPERATURE", "0.7")),
+        max_tokens=int(os.getenv("DEFAULT_MAX_TOKENS", "4000"))
+    )
+
+def get_available_routes():
+    """Get available route options for current minion system"""
+    return [
+        "",            # Auto route selection (empty for automatic)
+        "raw",         # Raw LLM output without processing
+        "native",      # Native minion processing
+        "cot",         # Chain of Thought reasoning
+        "dcot",        # Dynamic Chain of Thought
+        "plan",        # Planning-based approach
+        "python"       # Python code execution
+    ]
+
+def create_custom_llm_config(api_type: str, api_key: str, base_url: str, 
+                           api_version: str, model: str, temperature: float, 
+                           max_tokens: int) -> Dict[str, Any]:
+    """Create custom LLM configuration"""
+    return {
+        'api_type': api_type,
+        'api_key': api_key,
+        'base_url': base_url,
+        'api_version': api_version,
+        'model': model,
+        'temperature': temperature,
+        'max_tokens': max_tokens,
+        'vision_enabled': False
+    }
+
+def build_brain_with_config(llm_config_dict: Dict[str, Any]):
+    """Build brain with specified configuration"""
+    # Create a config object similar to LLMConfig
+    class Config:
+        def __init__(self, config_dict):
+            for key, value in config_dict.items():
+                setattr(self, key, value)
+    
+    config_obj = Config(llm_config_dict)
+    llm = create_llm_provider(config_obj)
     python_env = LocalPythonEnv(verbose=False)
     brain = Brain(
         python_env=python_env,
@@ -21,23 +124,193 @@ def build_brain():
     )
     return brain
 
-brain = build_brain()
+# Get preset configurations and default configuration
+preset_configs = get_preset_configs()
+default_config = get_default_config()
+available_routes = get_available_routes()
 
-async def minion_respond_async(query):
-    obs, score, *_ = await brain.step(query=query, route="python", check=False)
+async def minion_respond_async(query: str, preset_model: str, api_type: str, 
+                             api_key: str, base_url: str, api_version: str, 
+                             model: str, temperature: float, max_tokens: int,
+                             route: str, check_enabled: bool):
+    """Respond to query using specified configuration"""
+    
+    # If a preset model is selected, use preset configuration
+    if preset_model != "Custom":
+        config_obj = preset_configs.get(preset_model, default_config)
+        llm_config_dict = {
+            'api_type': config_obj.api_type,
+            'api_key': config_obj.api_key,
+            'base_url': config_obj.base_url,
+            'api_version': config_obj.api_version,
+            'model': config_obj.model,
+            'temperature': config_obj.temperature,
+            'max_tokens': config_obj.max_tokens,
+            'vision_enabled': config_obj.vision_enabled
+        }
+    else:
+        # Use custom configuration
+        llm_config_dict = create_custom_llm_config(
+            api_type, api_key, base_url, api_version, model, temperature, max_tokens
+        )
+    
+    brain = build_brain_with_config(llm_config_dict)
+    # Handle empty route selection for auto route
+    route_param = route if route else None
+    obs, score, *_ = await brain.step(query=query, route=route_param, check=check_enabled)
     return obs
 
-def minion_respond(query):
-    # gradio sync接口，自动调度async
-    return asyncio.run(minion_respond_async(query))
-
-demo = gr.Interface(
-    fn=minion_respond,
-    inputs="text",
-    outputs="text",
-    title="Minion Brain Chat",
-    description="用 Minion1 Brain 作为后端的智能问答"
-)
+def minion_respond(query: str, preset_model: str, api_type: str, api_key: str, 
+                  base_url: str, api_version: str, model: str, temperature: float, 
+                  max_tokens: int, route: str, check_enabled: bool):
+    """Gradio sync interface, automatically schedules async"""
+    return asyncio.run(minion_respond_async(
+        query, preset_model, api_type, api_key, base_url, 
+        api_version, model, temperature, max_tokens, route, check_enabled
+    ))
+
+def update_fields(preset_model: str):
+    """Update other fields when preset model is selected"""
+    if preset_model == "Custom":
+        # Return default values, let user configure themselves
+        return (
+            default_config.api_type,
+            "",  # Don't display API key 
+            default_config.base_url,
+            default_config.api_version,
+            default_config.model,
+            default_config.temperature,
+            default_config.max_tokens
+        )
+    else:
+        config_obj = preset_configs.get(preset_model, default_config)
+        return (
+            config_obj.api_type,
+            "***hidden***",  # Hide API key display
+            config_obj.base_url,
+            config_obj.api_version,
+            config_obj.model,
+            config_obj.temperature,
+            config_obj.max_tokens
+        )
+
+# Create Gradio interface
+with gr.Blocks(title="Minion Brain Chat") as demo:
+    gr.Markdown("# Minion Brain Chat\nIntelligent Q&A powered by Minion1 Brain")
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            query_input = gr.Textbox(
+                label="Enter your question",
+                placeholder="Please enter your question...",
+                lines=3
+            )
+            submit_btn = gr.Button("Submit", variant="primary")
+            
+        with gr.Column(scale=1):
+            # Move route selection to the front
+            route_dropdown = gr.Dropdown(
+                label="Route",
+                choices=available_routes,
+                value="",
+                info="empty: auto select, raw: direct LLM, native: standard, cot: chain of thought, dcot: dynamic cot, plan: planning, python: code execution"
+            )
+            
+            # Add check option
+            check_checkbox = gr.Checkbox(
+                label="Enable Check",
+                value=False,
+                info="Enable output verification and validation"
+            )
+            
+            preset_dropdown = gr.Dropdown(
+                label="Preset Model",
+                choices=["Custom"] + list(preset_configs.keys()),
+                value="gpt-4o",
+                info="Select preset configuration or custom"
+            )
+            
+            api_type_input = gr.Textbox(
+                label="API Type",
+                value=default_config.api_type,
+                info="openai, azure, ollama, groq etc."
+            )
+            
+            api_key_input = gr.Textbox(
+                label="API Key",
+                value="***hidden***",
+                type="password",
+                info="Your API key"
+            )
+            
+            base_url_input = gr.Textbox(
+                label="Base URL",
+                value=default_config.base_url,
+                info="API base URL"
+            )
+            
+            api_version_input = gr.Textbox(
+                label="API Version",
+                value=default_config.api_version,
+                info="API version (required for Azure)"
+            )
+            
+            model_input = gr.Textbox(
+                label="Model",
+                value=default_config.model,
+                info="Model name"
+            )
+            
+            temperature_input = gr.Slider(
+                label="Temperature",
+                minimum=0.0,
+                maximum=2.0,
+                value=default_config.temperature,
+                step=0.1,
+                info="Control output randomness"
+            )
+            
+            max_tokens_input = gr.Slider(
+                label="Max Tokens",
+                minimum=100,
+                maximum=8000,
+                value=default_config.max_tokens,
+                step=100,
+                info="Maximum number of tokens to generate"
+            )
+    
+    # Move Answer section up
+    output = gr.Textbox(
+        label="Answer",
+        lines=10,
+        show_copy_button=True
+    )
+    
+    # Update other fields when preset model changes
+    preset_dropdown.change(
+        fn=update_fields,
+        inputs=[preset_dropdown],
+        outputs=[api_type_input, api_key_input, base_url_input, 
+                api_version_input, model_input, temperature_input, max_tokens_input]
+    )
+    
+    # Submit button event
+    submit_btn.click(
+        fn=minion_respond,
+        inputs=[query_input, preset_dropdown, api_type_input, api_key_input, 
+               base_url_input, api_version_input, model_input, temperature_input, 
+               max_tokens_input, route_dropdown, check_checkbox],
+        outputs=[output]
+    )
+    
+    # Enter key submit
+    query_input.submit(
+        fn=minion_respond,
+        inputs=[query_input, preset_dropdown, api_type_input, api_key_input, 
+               base_url_input, api_version_input, model_input, temperature_input, 
+               max_tokens_input, route_dropdown, check_checkbox],
+        outputs=[output]
+    )
 
 if __name__ == "__main__":
     demo.launch(mcp_server=True)

requirements.txt

@@ -1,3 +1,4 @@
 gradio[mcp]==5.32.0
 huggingface_hub>=0.28.1
-minionx>=0.1.1
+minionx>=0.1.2
+python-dotenv>=1.0.0