Update app.py

app.py

@@ -1,262 +1,431 @@
-# app.py - General AI Chat API Gateway
+# app.py - General AI Gateway (No specific prompts, 100% free)
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, List
 import time
 import json
 import os
+import requests
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 app = FastAPI(
-    title="General AI Chat API",
-    description="Simple API gateway - accepts any prompt and returns as-is. All logic handled by n8n.",
-    version="1.0.0"
+    title="General AI Chat Gateway",
+    description="General AI gateway. All prompts/instructions come from n8n. Supports multiple free AI providers.",
+    version="2.0.0"
 )
 
-# Request models
+# Configuration for FREE AI providers
+FREE_AI_PROVIDERS = {
+    "openrouter": {
+        "url": "https://openrouter.ai/api/v1/chat/completions",
+        "free_model": "mistralai/mistral-7b-instruct:free",
+        "paid_model": "meta-llama/llama-3.1-8b-instruct:free"
+    },
+    "groq": {
+        "url": "https://api.groq.com/openai/v1/chat/completions",
+        "free_model": "llama-3.1-8b-instruct",
+        "requires_key": True
+    },
+    "google": {
+        "url": "https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent",
+        "requires_key": True
+    }
+}
+
+# Request models - GENERAL, no specific prompts
 class ChatRequest(BaseModel):
-    """General chat request - accepts any structure"""
-    messages: Optional[list] = None
+    """General chat request - ALL prompts come from n8n"""
+    # Messages in OpenAI format
+    messages: Optional[List[Dict[str, str]]] = None
+    
+    # OR simple prompt/content format
     prompt: Optional[str] = None
-    instruction: Optional[str] = None
     content: Optional[str] = None
-    parameters: Optional[Dict[str, Any]] = None
+    
+    # Configuration
+    provider: Optional[str] = "openrouter"  # openrouter, groq, google
+    model: Optional[str] = None  # Specific model if needed
+    parameters: Optional[Dict[str, Any]] = None  # temperature, max_tokens, etc.
+    
+    # Metadata from n8n
     metadata: Optional[Dict[str, Any]] = None
     
-    # For compatibility with different formats
+    # Compatibility
     text: Optional[str] = None
     query: Optional[str] = None
-    data: Optional[Any] = None
+    instruction: Optional[str] = None
 
 class ChatResponse(BaseModel):
+    """AI response"""
     success: bool
     response: str
-    received_at: str
+    provider: str
+    model: str
     processing_time_ms: float
-    echo: Optional[Dict[str, Any]] = None  # Echo back what you sent
+    is_free: bool
+    error: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
 
 class HealthResponse(BaseModel):
     status: str
     service: str
+    free_providers: List[str]
     timestamp: str
-    uptime: float
 
-# Startup time
-startup_time = time.time()
+class FreeAIGateway:
+    """Free AI Gateway - routes to different free providers"""
+    
+    def __init__(self):
+        self.providers = FREE_AI_PROVIDERS
+        # Get API keys from environment
+        self.api_keys = {
+            "openrouter": os.getenv("OPENROUTER_API_KEY", ""),
+            "groq": os.getenv("GROQ_API_KEY", ""),
+            "google": os.getenv("GOOGLE_API_KEY", "")
+        }
+        
+        logger.info("✅ Free AI Gateway initialized")
+        logger.info(f"Available providers: {list(self.providers.keys())}")
+    
+    def process(self, 
+                messages: List[Dict[str, str]] = None,
+                prompt: str = None,
+                content: str = None,
+                provider: str = "openrouter",
+                **kwargs) -> Dict[str, Any]:
+        """Process chat request with free AI"""
+        
+        # Prepare messages from different formats
+        final_messages = self._prepare_messages(messages, prompt, content)
+        
+        # Route to selected provider
+        if provider == "openrouter":
+            return self._call_openrouter(final_messages, **kwargs)
+        elif provider == "groq":
+            return self._call_groq(final_messages, **kwargs)
+        elif provider == "google":
+            return self._call_google(final_messages, **kwargs)
+        else:
+            return self._fallback_response(final_messages, f"Unknown provider: {provider}")
+    
+    def _prepare_messages(self, messages, prompt, content):
+        """Prepare messages in OpenAI format"""
+        if messages:
+            return messages
+        
+        # Convert prompt/content to messages format
+        result_messages = []
+        
+        # Add system prompt if provided in metadata
+        system_prompt = "You are a helpful AI assistant."
+        
+        result_messages.append({"role": "system", "content": system_prompt})
+        
+        # Add user message
+        user_message = ""
+        if prompt and content:
+            user_message = f"{prompt}\n\n{content}"
+        elif prompt:
+            user_message = prompt
+        elif content:
+            user_message = content
+        
+        if user_message:
+            result_messages.append({"role": "user", "content": user_message})
+        
+        return result_messages
+    
+    def _call_openrouter(self, messages: List[Dict[str, str]], **kwargs) -> Dict[str, Any]:
+        """Call OpenRouter (FREE tier available)"""
+        try:
+            api_key = self.api_keys["openrouter"]
+            model = kwargs.get("model") or self.providers["openrouter"]["free_model"]
+            
+            headers = {
+                "Authorization": f"Bearer {api_key}" if api_key else "",
+                "Content-Type": "application/json",
+                "HTTP-Referer": "https://huggingface.co",
+                "X-Title": "AI Chat Gateway"
+            }
+            
+            payload = {
+                "model": model,
+                "messages": messages,
+                "temperature": kwargs.get("temperature", 0.7),
+                "max_tokens": kwargs.get("max_tokens", 1000),
+                "stream": False
+            }
+            
+            logger.info(f"📤 Calling OpenRouter with model: {model}")
+            
+            response = requests.post(
+                self.providers["openrouter"]["url"],
+                headers=headers,
+                json=payload,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                return {
+                    "success": True,
+                    "content": result["choices"][0]["message"]["content"],
+                    "provider": "openrouter",
+                    "model": result["model"],
+                    "is_free": True
+                }
+            else:
+                error_msg = f"OpenRouter error: {response.status_code}"
+                return self._fallback_response(messages, error_msg)
+                
+        except Exception as e:
+            error_msg = f"OpenRouter exception: {str(e)}"
+            return self._fallback_response(messages, error_msg)
+    
+    def _call_groq(self, messages: List[Dict[str, str]], **kwargs) -> Dict[str, Any]:
+        """Call Groq (FREE tier available)"""
+        try:
+            api_key = self.api_keys["groq"]
+            if not api_key:
+                return self._fallback_response(messages, "Groq API key not configured")
+            
+            model = kwargs.get("model") or self.providers["groq"]["free_model"]
+            
+            headers = {
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json"
+            }
+            
+            payload = {
+                "model": model,
+                "messages": messages,
+                "temperature": kwargs.get("temperature", 0.7),
+                "max_tokens": kwargs.get("max_tokens", 1000)
+            }
+            
+            logger.info(f"📤 Calling Groq with model: {model}")
+            
+            response = requests.post(
+                self.providers["groq"]["url"],
+                headers=headers,
+                json=payload,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                return {
+                    "success": True,
+                    "content": result["choices"][0]["message"]["content"],
+                    "provider": "groq",
+                    "model": result["model"],
+                    "is_free": True
+                }
+            else:
+                error_msg = f"Groq error: {response.status_code}"
+                return self._fallback_response(messages, error_msg)
+                
+        except Exception as e:
+            error_msg = f"Groq exception: {str(e)}"
+            return self._fallback_response(messages, error_msg)
+    
+    def _call_google(self, messages: List[Dict[str, str]], **kwargs) -> Dict[str, Any]:
+        """Call Google AI (FREE tier available)"""
+        try:
+            api_key = self.api_keys["google"]
+            if not api_key:
+                return self._fallback_response(messages, "Google API key not configured")
+            
+            # Convert OpenAI format to Google format
+            last_user_message = ""
+            for msg in reversed(messages):
+                if msg.get("role") == "user":
+                    last_user_message = msg.get("content", "")
+                    break
+            
+            url = f"{self.providers['google']['url']}?key={api_key}"
+            
+            payload = {
+                "contents": [{
+                    "parts": [{"text": last_user_message}]
+                }],
+                "generationConfig": {
+                    "temperature": kwargs.get("temperature", 0.7),
+                    "maxOutputTokens": kwargs.get("max_tokens", 1000)
+                }
+            }
+            
+            logger.info("📤 Calling Google AI")
+            
+            response = requests.post(
+                url,
+                json=payload,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                if "candidates" in result and len(result["candidates"]) > 0:
+                    return {
+                        "success": True,
+                        "content": result["candidates"][0]["content"]["parts"][0]["text"],
+                        "provider": "google",
+                        "model": "gemini-pro",
+                        "is_free": True
+                    }
+                else:
+                    return self._fallback_response(messages, "Google AI returned no candidates")
+            else:
+                error_msg = f"Google AI error: {response.status_code}"
+                return self._fallback_response(messages, error_msg)
+                
+        except Exception as e:
+            error_msg = f"Google AI exception: {str(e)}"
+            return self._fallback_response(messages, error_msg)
+    
+    def _fallback_response(self, messages: List[Dict[str, str]], error: str = None) -> Dict[str, Any]:
+        """Fallback response when AI fails"""
+        # Extract last user message
+        last_user_message = ""
+        for msg in reversed(messages):
+            if msg.get("role") == "user":
+                last_user_message = msg.get("content", "")
+                break
+        
+        if error:
+            content = f"⚠️ AI暂时不可用（{error}）。\n\n收到：{last_user_message[:100]}..."
+        else:
+            content = f"🤖 AI处理响应：\n\n已收到您的请求：{last_user_message[:150]}..."
+        
+        return {
+            "success": False,
+            "content": content,
+            "provider": "fallback",
+            "model": "none",
+            "is_free": True
+        }
+
+# Initialize gateway
+ai_gateway = FreeAIGateway()
 
 @app.get("/")
 async def root():
     return {
         "status": "online",
-        "service": "General AI Chat API",
-        "description": "Accepts any prompt/instruction from n8n. All logic handled by n8n workflow.",
+        "service": "Free AI Chat Gateway",
+        "description": "General AI gateway. ALL prompts come from n8n.",
+        "free_providers": list(FREE_AI_PROVIDERS.keys()),
         "endpoints": {
-            "/chat": "POST - General chat endpoint",
-            "/process": "POST - Process endpoint (legacy)",
-            "/webhook": "POST - Webhook endpoint",
+            "/chat": "POST - AI chat with free providers",
+            "/process": "POST - Simple processing",
             "/health": "GET - Health check",
-            "/echo": "POST - Echo test endpoint"
+            "/providers": "GET - Available providers"
         },
-        "usage": "Send any JSON payload. It will be processed by your n8n workflow logic."
+        "note": "Configure API keys in environment for better performance"
     }
 
 @app.get("/health", response_model=HealthResponse)
 async def health():
     return HealthResponse(
         status="healthy",
-        service="AI Chat Gateway",
-        timestamp=time.strftime("%Y-%m-%d %H:%M:%S"),
-        uptime=time.time() - startup_time
+        service="Free AI Chat Gateway",
+        free_providers=list(FREE_AI_PROVIDERS.keys()),
+        timestamp=time.strftime("%Y-%m-%d %H:%M:%S")
     )
 
+@app.get("/providers")
+async def list_providers():
+    return {
+        "available_providers": list(FREE_AI_PROVIDERS.keys()),
+        "recommended": "openrouter (no API key needed for free tier)",
+        "configuration_needed": {
+            "openrouter": "optional (better rate limits)",
+            "groq": "required",
+            "google": "required"
+        }
+    }
+
 @app.post("/chat", response_model=ChatResponse)
 async def chat(request: ChatRequest):
+    """Main chat endpoint - ALL prompts come from n8n"""
     start_time = time.time()
     
     try:
-        # DEBUG: Log what we received
-        print(f"📨 Received request:")
-        print(f"  Prompt: {request.prompt}")
-        print(f"  Content: {request.content}")
-        print(f"  Content length: {len(request.content) if request.content else 0}")
-        
-        # FIXED: Properly extract content
-        text_to_process = ""
-        
-        # Priority 1: Use content field
-        if request.content:
-            text_to_process = f"{request.prompt or ''}\n\n{request.content}"
-        # Priority 2: Use prompt if no content
-        elif request.prompt:
-            text_to_process = request.prompt
-        # Priority 3: Use other fields
-        elif request.text:
-            text_to_process = request.text
-        elif request.query:
-            text_to_process = request.query
-        elif request.instruction:
-            text_to_process = request.instruction
-        elif request.messages:
-            text_to_process = str(request.messages)
-        elif request.data:
-            text_to_process = str(request.data)
-        else:
-            text_to_process = "No content provided"
-        
-        print(f"📤 Text to process: {text_to_process[:100]}...")
+        # Get provider from request or use default
+        provider = request.provider or "openrouter"
         
-        # For messages array (OpenAI format)
-        if request.messages:
-            # Extract last user message
-            user_messages = [msg for msg in request.messages if msg.get("role") == "user"]
-            if user_messages:
-                text_to_process = user_messages[-1].get("content", text_to_process)
+        # Get parameters
+        params = request.parameters or {}
         
-        # Simple processing - just echo/acknowledge
-        # In reality, n8n will replace this with actual AI processing
-        response_text = f"✅ Received at {time.strftime('%H:%M:%S')}:\n\n{text_to_process[:500]}"
-        
-        # Add note about processing
-        if len(text_to_process) > 500:
-            response_text += f"\n\n... (truncated, total {len(text_to_process)} characters)"
+        # Process with AI gateway
+        ai_result = ai_gateway.process(
+            messages=request.messages,
+            prompt=request.prompt,
+            content=request.content or request.text or request.query,
+            provider=provider,
+            **params
+        )
         
-        processing_time = (time.time() - start_time) * 1000  # Convert to ms
+        processing_time = (time.time() - start_time) * 1000
         
         return ChatResponse(
-            success=True,
-            response=response_text,
-            received_at=time.strftime("%Y-%m-%d %H:%M:%S"),
+            success=ai_result["success"],
+            response=ai_result["content"],
+            provider=ai_result["provider"],
+            model=ai_result["model"],
             processing_time_ms=processing_time,
-            echo={
-                "original_length": len(text_to_process),
-                "fields_received": list(request.model_dump(exclude_none=True).keys()),
-                "timestamp": time.time()
-            }
+            is_free=ai_result["is_free"],
+            metadata=request.metadata
         )
         
     except Exception as e:
         processing_time = (time.time() - start_time) * 1000
+        logger.error(f"Error in /chat: {str(e)}")
+        
         return ChatResponse(
             success=False,
-            response=f"Error: {str(e)}",
-            received_at=time.strftime("%Y-%m-%d %H:%M:%S"),
-            processing_time_ms=processing_time
+            response=f"处理错误：{str(e)[:100]}",
+            provider="error",
+            model="none",
+            processing_time_ms=processing_time,
+            is_free=True,
+            error=str(e)
         )
 
-@app.post("/process", response_model=ChatResponse)
+@app.post("/process")
 async def process(request: Dict[str, Any]):
-    """
-    Legacy endpoint - accepts any JSON structure
-    Compatible with previous versions
-    """
+    """Legacy endpoint"""
     start_time = time.time()
     
     try:
-        # Extract text from any field
-        text = ""
-        for key in ['prompt', 'text', 'content', 'message', 'query', 'input']:
-            if key in request and request[key]:
-                text = str(request[key])
-                break
-        
-        if not text:
-            text = json.dumps(request)[:500]
-        
-        processing_time = (time.time() - start_time) * 1000
-        
-        return ChatResponse(
-            success=True,
-            response=f"📥 Process endpoint received:\n\n{text[:400]}...",
-            received_at=time.strftime("%Y-%m-%d %H:%M:%S"),
-            processing_time_ms=processing_time,
-            echo={"original_request": request}
+        ai_result = ai_gateway.process(
+            prompt=request.get("prompt", ""),
+            content=request.get("content", request.get("text", "")),
+            provider=request.get("provider", "openrouter")
         )
         
-    except Exception as e:
-        processing_time = (time.time() - start_time) * 1000
-        return ChatResponse(
-            success=False,
-            response=f"Error in /process: {str(e)}",
-            received_at=time.strftime("%Y-%m-%d %H:%M:%S"),
-            processing_time_ms=processing_time
-        )
-
-@app.post("/webhook")
-async def webhook(request: Dict[str, Any]):
-    """
-    Webhook endpoint for n8n
-    """
-    try:
-        # Log the webhook
-        print(f"📨 Webhook received: {json.dumps(request, indent=2)[:200]}...")
-        
-        # Extract useful info
-        webhook_id = request.get("webhookId")
-        workflow_id = request.get("workflowId")
-        
-        # Echo back with some processing
         return {
-            "success": True,
-            "message": "Webhook received successfully",
-            "webhook_id": webhook_id,
-            "workflow_id": workflow_id,
-            "received_at": time.strftime("%Y-%m-%d %H:%M:%S"),
-            "data_preview": str(request)[:200] + "..." if len(str(request)) > 200 else str(request)
+            "success": ai_result["success"],
+            "result": ai_result["content"],
+            "provider": ai_result["provider"],
+            "processing_time_ms": (time.time() - start_time) * 1000
         }
         
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/echo")
-async def echo(request: Dict[str, Any]):
-    """
-    Simple echo endpoint for testing
-    """
-    return {
-        "status": "echo",
-        "received": request,
-        "timestamp": time.time(),
-        "headers": {"content-type": "application/json"},
-        "note": "This is exactly what you sent me"
-    }
-
-# Batch endpoint
-@app.post("/batch")
-async def batch_process(requests: list):
-    """
-    Process multiple requests at once
-    """
-    responses = []
-    
-    for i, req in enumerate(requests):
-        responses.append({
-            "index": i,
-            "success": True,
-            "response": f"Processed item {i}: {str(req)[:100]}...",
-            "original_length": len(str(req))
-        })
-    
-    return {
-        "batch_size": len(requests),
-        "responses": responses,
-        "processed_at": time.strftime("%Y-%m-%d %H:%M:%S")
-    }
-
-# Test endpoint
-@app.get("/test")
-async def test_endpoint(prompt: str = "Hello, test!"):
-    """
-    GET endpoint for quick testing
-    """
-    return {
-        "test": "success",
-        "your_prompt": prompt,
-        "response": f"Test response to: {prompt}",
-        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
-    }
+        return {
+            "success": False,
+            "result": f"Error: {str(e)}",
+            "provider": "error"
+        }
 
 if __name__ == "__main__":
     import uvicorn
     port = int(os.getenv("PORT", 7860))
-    print(f"🚀 Starting General AI Chat API on port {port}")
-    print("📝 Description: Simple gateway - all logic handled by n8n")
+    logger.info(f"🚀 Starting Free AI Chat Gateway on port {port}")
+    logger.info("🎯 ALL prompts come from n8n - this is a general gateway")
+    logger.info("🆓 Using free AI providers")
     uvicorn.run(app, host="0.0.0.0", port=port)