Spaces:

openfree
/

Chain-of-Recursive-Thoughts

Running

App Files Files Community

openfree commited on 16 days ago

Commit

e3e9b56

verified ·

1 Parent(s): 86c2e4c

Upload 3 files

Browse files

Files changed (3) hide show

app (35).py +608 -0
recursive_thinking_ai.py +291 -0
requirements (16).txt +13 -0

app (35).py ADDED Viewed

	@@ -0,0 +1,608 @@

+from fastapi import FastAPI, WebSocket, HTTPException, WebSocketDisconnect
+from fastapi.responses import JSONResponse, HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+import uvicorn
+import json
+import os
+import asyncio
+from datetime import datetime
+from typing import List, Dict, Optional, Any
+import logging
+import uuid
+# 모듈이 존재하지 않으면 현재 디렉토리에서 가져오도록 시도
+try:
+    from recursive_thinking_ai import EnhancedRecursiveThinkingChat
+except ModuleNotFoundError:
+    # 현재 디렉토리에 recursive_thinking_ai.py 파일이 있어야 함
+    import sys
+    sys.path.append('.')
+    from recursive_thinking_ai import EnhancedRecursiveThinkingChat
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+app = FastAPI(
+    title="RecThink API",
+    description="API for Enhanced Recursive Thinking Chat",
+    version="1.0.0"
+)
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, replace with specific origins
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+# Create a dictionary to store chat instances
+chat_instances = {}
+# Pydantic models for request/response validation
+class ChatConfig(BaseModel):
+    api_key: str
+    model: str = "mistralai/mistral-small-3.1-24b-instruct:free"
+    temperature: Optional[float] = Field(default=0.7, ge=0.0, le=1.0)
+class MessageRequest(BaseModel):
+    session_id: str
+    message: str
+    thinking_rounds: Optional[int] = Field(default=None, ge=1, le=10)
+    alternatives_per_round: Optional[int] = Field(default=3, ge=1, le=5)
+    temperature: Optional[float] = Field(default=None, ge=0.0, le=1.0)
+class SaveRequest(BaseModel):
+    session_id: str
+    filename: Optional[str] = None
+    full_log: bool = False
+class SessionInfo(BaseModel):
+    session_id: str
+    message_count: int
+    created_at: str
+    model: str
+class SessionResponse(BaseModel):
+    sessions: List[SessionInfo]
+class InitResponse(BaseModel):
+    session_id: str
+    status: str
+# 간단한 HTML 인터페이스 제공
+@app.get("/", response_class=HTMLResponse)
+async def root():
+    """Root endpoint with a simple HTML interface"""
+    html_content = """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>RecThink API</title>
+        <style>
+            body {
+                font-family: Arial, sans-serif;
+                max-width: 800px;
+                margin: 0 auto;
+                padding: 20px;
+                line-height: 1.6;
+            }
+            h1 {
+                color: #333;
+                border-bottom: 1px solid #eee;
+                padding-bottom: 10px;
+            }
+            .container {
+                background-color: #f9f9f9;
+                border-radius: 5px;
+                padding: 20px;
+                margin-top: 20px;
+            }
+            label {
+                display: block;
+                margin-bottom: 5px;
+                font-weight: bold;
+            }
+            input, textarea, select {
+                width: 100%;
+                padding: 8px;
+                margin-bottom: 10px;
+                border: 1px solid #ddd;
+                border-radius: 4px;
+            }
+            button {
+                background-color: #4CAF50;
+                color: white;
+                padding: 10px 15px;
+                border: none;
+                border-radius: 4px;
+                cursor: pointer;
+            }
+            button:hover {
+                background-color: #45a049;
+            }
+            #response {
+                white-space: pre-wrap;
+                background-color: #f5f5f5;
+                padding: 15px;
+                border-radius: 4px;
+                margin-top: 20px;
+                min-height: 100px;
+            }
+            .log {
+                margin-top: 20px;
+                font-size: 0.9em;
+                color: #666;
+            }
+        </style>
+    </head>
+    <body>
+        <h1>RecThink API 인터페이스</h1>
+        <div class="container">
+            <div id="init-form">
+                <h2>1. 채팅 초기화</h2>
+                <label for="api-key">OpenRouter API 키:</label>
+                <input type="text" id="api-key" placeholder="OpenRouter API 키를 입력하세요">
+                <label for="model">모델:</label>
+                <input type="text" id="model" value="mistralai/mistral-small-3.1-24b-instruct:free">
+                <label for="temperature">온도 (Temperature):</label>
+                <input type="number" id="temperature" min="0" max="1" step="0.1" value="0.7">
+                <button onclick="initializeChat()">초기화</button>
+            </div>
+            <div id="chat-form" style="display: none;">
+                <h2>2. 메시지 전송</h2>
+                <p>세션 ID: <span id="session-id"></span></p>
+                <label for="message">메시지:</label>
+                <textarea id="message" rows="4" placeholder="메시지를 입력하세요"></textarea>
+                <label for="thinking-rounds">사고 라운드 (선택사항):</label>
+                <input type="number" id="thinking-rounds" min="1" max="10" placeholder="자동 결정">
+                <label for="alternatives">대안 개수 (선택사항):</label>
+                <input type="number" id="alternatives" min="1" max="5" value="3">
+                <button onclick="sendMessage()">전송</button>
+                <button onclick="resetChat()" style="background-color: #f44336;">초기화</button>
+            </div>
+            <div id="response-container" style="display: none;">
+                <h2>3. 응답</h2>
+                <div id="response">응답이 여기에 표시됩니다...</div>
+                <div class="log">
+                    <h3>생각 과정 로그:</h3>
+                    <div id="thinking-log"></div>
+                </div>
+            </div>
+        </div>
+        <script>
+            let currentSessionId = null;
+            async function initializeChat() {
+                const apiKey = document.getElementById('api-key').value;
+                const model = document.getElementById('model').value;
+                const temperature = parseFloat(document.getElementById('temperature').value);
+                if (!apiKey) {
+                    alert('API 키를 입력해주세요');
+                    return;
+                }
+                try {
+                    const response = await fetch('/api/initialize', {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify({
+                            api_key: apiKey,
+                            model: model,
+                            temperature: temperature
+                        }),
+                    });
+                    const data = await response.json();
+                    if (response.ok) {
+                        currentSessionId = data.session_id;
+                        document.getElementById('session-id').textContent = currentSessionId;
+                        document.getElementById('init-form').style.display = 'none';
+                        document.getElementById('chat-form').style.display = 'block';
+                        document.getElementById('response-container').style.display = 'block';
+                    } else {
+                        alert('초기화 실패: ' + (data.detail || '알 수 없는 오류'));
+                    }
+                } catch (error) {
+                    alert('오류 발생: ' + error.message);
+                }
+            }
+            async function sendMessage() {
+                if (!currentSessionId) {
+                    alert('먼저 채팅을 초기화해주세요');
+                    return;
+                }
+                const message = document.getElementById('message').value;
+                const thinkingRounds = document.getElementById('thinking-rounds').value;
+                const alternatives = document.getElementById('alternatives').value;
+                if (!message) {
+                    alert('메시지를 입력해주세요');
+                    return;
+                }
+                document.getElementById('response').textContent = '처리 중...';
+                document.getElementById('thinking-log').textContent = '';
+                try {
+                    const response = await fetch('/api/send_message', {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify({
+                            session_id: currentSessionId,
+                            message: message,
+                            thinking_rounds: thinkingRounds ? parseInt(thinkingRounds) : null,
+                            alternatives_per_round: alternatives ? parseInt(alternatives) : 3
+                        }),
+                    });
+                    const data = await response.json();
+                    if (response.ok) {
+                        document.getElementById('response').textContent = data.response;
+                        // Display thinking history
+                        let thinkingLogHTML = '';
+                        data.thinking_history.forEach(item => {
+                            const selected = item.selected ? ' ✓ 선택됨' : '';
+                            thinkingLogHTML += `<p><strong>라운드 ${item.round}${selected}:</strong> `;
+                            if (item.explanation && item.selected) {
+                                thinkingLogHTML += `<br><em>선택 이유: ${item.explanation}</em>`;
+                            }
+                            thinkingLogHTML += '</p>';
+                        });
+                        document.getElementById('thinking-log').innerHTML = thinkingLogHTML;
+                    } else {
+                        document.getElementById('response').textContent = '오류: ' + (data.detail || '알 수 없는 오류');
+                    }
+                } catch (error) {
+                    document.getElementById('response').textContent = '오류 발생: ' + error.message;
+                }
+            }
+            function resetChat() {
+                currentSessionId = null;
+                document.getElementById('init-form').style.display = 'block';
+                document.getElementById('chat-form').style.display = 'none';
+                document.getElementById('response-container').style.display = 'none';
+                document.getElementById('message').value = '';
+                document.getElementById('thinking-rounds').value = '';
+                document.getElementById('alternatives').value = '3';
+            }
+        </script>
+    </body>
+    </html>
+    """
+    return html_content
+# Healthcheck endpoint
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy", "timestamp": datetime.now().isoformat()}
+@app.post("/api/initialize", response_model=InitResponse)
+async def initialize_chat(config: ChatConfig):
+    """Initialize a new chat session"""
+    try:
+        # Generate a session ID
+        session_id = f"session_{datetime.now().strftime('%Y%m%d%H%M%S')}_{uuid.uuid4().hex[:8]}"
+        # Initialize the chat instance
+        chat = EnhancedRecursiveThinkingChat(
+            api_key=config.api_key,
+            model=config.model,
+            temperature=config.temperature
+        )
+        chat_instances[session_id] = {
+            "chat": chat,
+            "created_at": datetime.now().isoformat(),
+            "model": config.model
+        }
+        return {"session_id": session_id, "status": "initialized"}
+    except Exception as e:
+        logger.error(f"Error initializing chat: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to initialize chat: {str(e)}")
+@app.post("/api/send_message")
+async def send_message(request: MessageRequest):
+    """Send a message and get a response with thinking process"""
+    try:
+        if request.session_id not in chat_instances:
+            raise HTTPException(status_code=404, detail="Session not found")
+        chat = chat_instances[request.session_id]["chat"]
+        # Override class parameters if provided
+        original_thinking_fn = chat._determine_thinking_rounds
+        original_alternatives_fn = chat._generate_alternatives
+        original_temperature = getattr(chat, "temperature", 0.7)
+        if request.thinking_rounds is not None:
+            # Override the thinking rounds determination
+            chat._determine_thinking_rounds = lambda _: request.thinking_rounds
+        if request.alternatives_per_round is not None:
+            # Store the original function
+            def modified_generate_alternatives(base_response, prompt, num_alternatives=3):
+                return original_alternatives_fn(base_response, prompt, request.alternatives_per_round)
+            chat._generate_alternatives = modified_generate_alternatives
+        # Override temperature if provided
+        if request.temperature is not None:
+            setattr(chat, "temperature", request.temperature)
+        # Process the message
+        logger.info(f"Processing message for session {request.session_id}")
+        start_time = datetime.now()
+        result = chat.think_and_respond(request.message, verbose=True)
+        processing_time = (datetime.now() - start_time).total_seconds()
+        logger.info(f"Message processed in {processing_time:.2f} seconds")
+        # Restore original functions and parameters
+        chat._determine_thinking_rounds = original_thinking_fn
+        chat._generate_alternatives = original_alternatives_fn
+        if request.temperature is not None:
+            setattr(chat, "temperature", original_temperature)
+        return {
+            "session_id": request.session_id,
+            "response": result["response"],
+            "thinking_rounds": result["thinking_rounds"],
+            "thinking_history": result["thinking_history"],
+            "processing_time": processing_time
+        }
+    except Exception as e:
+        logger.error(f"Error processing message: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to process message: {str(e)}")
+@app.post("/api/save")
+async def save_conversation(request: SaveRequest):
+    """Save the conversation or full thinking log"""
+    try:
+        if request.session_id not in chat_instances:
+            raise HTTPException(status_code=404, detail="Session not found")
+        chat = chat_instances[request.session_id]["chat"]
+        # Generate default filename if not provided
+        filename = request.filename
+        if filename is None:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            log_type = "full_log" if request.full_log else "conversation"
+            filename = f"recthink_{log_type}_{timestamp}.json"
+        # Make sure the output directory exists
+        os.makedirs("logs", exist_ok=True)
+        file_path = os.path.join("logs", filename)
+        if request.full_log:
+            chat.save_full_log(file_path)
+        else:
+            chat.save_conversation(file_path)
+        return {"status": "saved", "filename": filename, "path": file_path}
+    except Exception as e:
+        logger.error(f"Error saving conversation: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to save conversation: {str(e)}")
+@app.get("/api/sessions", response_model=SessionResponse)
+async def list_sessions():
+    """List all active chat sessions"""
+    sessions = []
+    for session_id, session_data in chat_instances.items():
+        chat = session_data["chat"]
+        message_count = len(chat.conversation_history) // 2  # Each message-response pair counts as 2
+        sessions.append(SessionInfo(
+            session_id=session_id,
+            message_count=message_count,
+            created_at=session_data["created_at"],
+            model=session_data["model"]
+        ))
+    return {"sessions": sessions}
+@app.get("/api/sessions/{session_id}")
+async def get_session(session_id: str):
+    """Get details for a specific chat session"""
+    if session_id not in chat_instances:
+        raise HTTPException(status_code=404, detail="Session not found")
+    session_data = chat_instances[session_id]
+    chat = session_data["chat"]
+    # Extract conversation history
+    conversation = []
+    for i in range(0, len(chat.conversation_history), 2):
+        if i+1 < len(chat.conversation_history):
+            conversation.append({
+                "user": chat.conversation_history[i],
+                "assistant": chat.conversation_history[i+1]
+            })
+    return {
+        "session_id": session_id,
+        "created_at": session_data["created_at"],
+        "model": session_data["model"],
+        "message_count": len(conversation),
+        "conversation": conversation
+    }
+@app.delete("/api/sessions/{session_id}")
+async def delete_session(session_id: str):
+    """Delete a chat session"""
+    if session_id not in chat_instances:
+        raise HTTPException(status_code=404, detail="Session not found")
+    del chat_instances[session_id]
+    return {"status": "deleted", "session_id": session_id}
+# WebSocket connection manager
+class ConnectionManager:
+    def __init__(self):
+        self.active_connections: Dict[str, WebSocket] = {}
+    async def connect(self, session_id: str, websocket: WebSocket):
+        await websocket.accept()
+        self.active_connections[session_id] = websocket
+    def disconnect(self, session_id: str):
+        if session_id in self.active_connections:
+            del self.active_connections[session_id]
+    async def send_json(self, session_id: str, data: dict):
+        if session_id in self.active_connections:
+            await self.active_connections[session_id].send_json(data)
+manager = ConnectionManager()
+# WebSocket for streaming thinking process
+@app.websocket("/ws/{session_id}")
+async def websocket_endpoint(websocket: WebSocket, session_id: str):
+    try:
+        await manager.connect(session_id, websocket)
+        if session_id not in chat_instances:
+            await websocket.send_json({"error": "Session not found"})
+            await websocket.close()
+            return
+        chat = chat_instances[session_id]["chat"]
+        # Set up a custom callback to stream thinking process
+        original_call_api = chat._call_api
+        async def stream_callback(chunk):
+            await manager.send_json(session_id, {"type": "chunk", "content": chunk})
+        # Override the _call_api method to also send updates via WebSocket
+        def ws_call_api(messages, temperature=0.7, stream=True):
+            result = original_call_api(messages, temperature, stream)
+            # Send the chunk via WebSocket if we're streaming
+            if stream:
+                asyncio.create_task(stream_callback(result))
+            return result
+        # Replace the method temporarily
+        chat._call_api = ws_call_api
+        # Wait for messages from the client
+        while True:
+            data = await websocket.receive_text()
+            message_data = json.loads(data)
+            if message_data["type"] == "message":
+                # Process the message
+                start_time = datetime.now()
+                try:
+                    # Get parameters if they exist
+                    thinking_rounds = message_data.get("thinking_rounds", None)
+                    alternatives_per_round = message_data.get("alternatives_per_round", None)
+                    temperature = message_data.get("temperature", None)
+                    # Override if needed
+                    original_thinking_fn = chat._determine_thinking_rounds
+                    original_alternatives_fn = chat._generate_alternatives
+                    original_temperature = getattr(chat, "temperature", 0.7)
+                    if thinking_rounds is not None:
+                        chat._determine_thinking_rounds = lambda _: thinking_rounds
+                    if alternatives_per_round is not None:
+                        def modified_generate_alternatives(base_response, prompt, num_alternatives=3):
+                            return original_alternatives_fn(base_response, prompt, alternatives_per_round)
+                        chat._generate_alternatives = modified_generate_alternatives
+                    if temperature is not None:
+                        setattr(chat, "temperature", temperature)
+                    # Send a status message that we've started processing
+                    await manager.send_json(session_id, {
+                        "type": "status",
+                        "status": "processing",
+                        "message": "Starting recursive thinking process..."
+                    })
+                    # Process the message
+                    result = chat.think_and_respond(message_data["content"], verbose=True)
+                    processing_time = (datetime.now() - start_time).total_seconds()
+                    # Restore original functions
+                    chat._determine_thinking_rounds = original_thinking_fn
+                    chat._generate_alternatives = original_alternatives_fn
+                    if temperature is not None:
+                        setattr(chat, "temperature", original_temperature)
+                    # Send the final result
+                    await manager.send_json(session_id, {
+                        "type": "final",
+                        "response": result["response"],
+                        "thinking_rounds": result["thinking_rounds"],
+                        "thinking_history": result["thinking_history"],
+                        "processing_time": processing_time
+                    })
+                except Exception as e:
+                    error_msg = str(e)
+                    logger.error(f"Error in WebSocket message processing: {error_msg}")
+                    await manager.send_json(session_id, {
+                        "type": "error",
+                        "error": error_msg
+                    })
+    except WebSocketDisconnect:
+        logger.info(f"WebSocket disconnected: {session_id}")
+        manager.disconnect(session_id)
+    except Exception as e:
+        error_msg = str(e)
+        logger.error(f"WebSocket error: {error_msg}")
+        try:
+            await websocket.send_json({"type": "error", "error": error_msg})
+        except:
+            pass
+    finally:
+        # Restore original method if needed
+        if 'chat' in locals() and 'original_call_api' in locals():
+            chat._call_api = original_call_api
+        # Make sure to disconnect
+        manager.disconnect(session_id)
+# 포트 설정 - 허깅페이스 스페이스에서는 7860 포트를 사용해야 함
+if __name__ == "__main__":
+    # 허깅페이스 스페이스에서 실행시 포트 7860 사용
+    port = 7860
+    print(f"Starting server on port {port}")
+    uvicorn.run("app:app", host="0.0.0.0", port=port)

recursive_thinking_ai.py ADDED Viewed

	@@ -0,0 +1,291 @@

+import openai
+import os
+from typing import List, Dict
+import json
+import requests
+from datetime import datetime
+import sys
+import time
+class EnhancedRecursiveThinkingChat:
+    def __init__(self, api_key: str = None, model: str = "mistralai/mistral-small-3.1-24b-instruct:free", temperature: float = 0.7):
+        """Initialize with OpenRouter API."""
+        self.api_key = api_key or os.getenv("OPENROUTER_API_KEY")
+        self.model = model
+        self.temperature = temperature
+        self.base_url = "https://openrouter.ai/api/v1/chat/completions"
+        self.headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "HTTP-Referer": "http://localhost:3000",
+            "X-Title": "Recursive Thinking Chat",
+            "Content-Type": "application/json"
+        }
+        self.conversation_history = []
+        self.full_thinking_log = []
+    def _call_api(self, messages: List[Dict], temperature: float = None, stream: bool = True) -> str:
+        """Make an API call to OpenRouter with streaming support."""
+        if temperature is None:
+            temperature = self.temperature
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "temperature": temperature,
+            "stream": stream,
+            "reasoning": {
+                "max_tokens": 10386,
+            }
+        }
+        try:
+            response = requests.post(self.base_url, headers=self.headers, json=payload, stream=stream)
+            response.raise_for_status()
+            if stream:
+                full_response = ""
+                for line in response.iter_lines():
+                    if line:
+                        line = line.decode('utf-8')
+                        if line.startswith("data: "):
+                            line = line[6:]
+                            if line.strip() == "[DONE]":
+                                break
+                            try:
+                                chunk = json.loads(line)
+                                if "choices" in chunk and len(chunk["choices"]) > 0:
+                                    delta = chunk["choices"][0].get("delta", {})
+                                    content = delta.get("content", "")
+                                    if content:
+                                        full_response += content
+                                        print(content, end="", flush=True)
+                            except json.JSONDecodeError:
+                                continue
+                print()  # New line after streaming
+                return full_response
+            else:
+                return response.json()['choices'][0]['message']['content'].strip()
+        except Exception as e:
+            print(f"API Error: {e}")
+            return "Error: Could not get response from API"
+    def _determine_thinking_rounds(self, prompt: str) -> int:
+        """Let the model decide how many rounds of thinking are needed."""
+        meta_prompt = f"""Given this message: "{prompt}"
+How many rounds of iterative thinking (1-5) would be optimal to generate the best response?
+Consider the complexity and nuance required.
+Respond with just a number between 1 and 5."""
+        messages = [{"role": "user", "content": meta_prompt}]
+        print("\n=== DETERMINING THINKING ROUNDS ===")
+        response = self._call_api(messages, temperature=0.3, stream=True)
+        print("=" * 50 + "\n")
+        try:
+            rounds = int(''.join(filter(str.isdigit, response)))
+            return min(max(rounds, 1), 5)
+        except:
+            return 3
+    def _generate_alternatives(self, base_response: str, prompt: str, num_alternatives: int = 3) -> List[str]:
+        """Generate alternative responses."""
+        alternatives = []
+        for i in range(num_alternatives):
+            print(f"\n=== GENERATING ALTERNATIVE {i+1} ===")
+            alt_prompt = f"""Original message: {prompt}
+Current response: {base_response}
+Generate an alternative response that might be better. Be creative and consider different approaches.
+Alternative response:"""
+            messages = self.conversation_history + [{"role": "user", "content": alt_prompt}]
+            alternative = self._call_api(messages, temperature=0.7 + i * 0.1, stream=True)
+            alternatives.append(alternative)
+            print("=" * 50)
+        return alternatives
+    def _evaluate_responses(self, prompt: str, current_best: str, alternatives: List[str]) -> tuple[str, str]:
+        """Evaluate responses and select the best one."""
+        print("\n=== EVALUATING RESPONSES ===")
+        eval_prompt = f"""Original message: {prompt}
+Evaluate these responses and choose the best one:
+Current best: {current_best}
+Alternatives:
+{chr(10).join([f"{i+1}. {alt}" for i, alt in enumerate(alternatives)])}
+Which response best addresses the original message? Consider accuracy, clarity, and completeness.
+First, respond with ONLY 'current' or a number (1-{len(alternatives)}).
+Then on a new line, explain your choice in one sentence."""
+        messages = [{"role": "user", "content": eval_prompt}]
+        evaluation = self._call_api(messages, temperature=0.2, stream=True)
+        print("=" * 50)
+        # Better parsing
+        lines = [line.strip() for line in evaluation.split('\n') if line.strip()]
+        choice = 'current'
+        explanation = "No explanation provided"
+        if lines:
+            first_line = lines[0].lower()
+            if 'current' in first_line:
+                choice = 'current'
+            else:
+                for char in first_line:
+                    if char.isdigit():
+                        choice = char
+                        break
+            if len(lines) > 1:
+                explanation = ' '.join(lines[1:])
+        if choice == 'current':
+            return current_best, explanation
+        else:
+            try:
+                index = int(choice) - 1
+                if 0 <= index < len(alternatives):
+                    return alternatives[index], explanation
+            except:
+                pass
+        return current_best, explanation
+    def think_and_respond(self, user_input: str, verbose: bool = True) -> Dict:
+        """Process user input with recursive thinking."""
+        print("\n" + "=" * 50)
+        print("🤔 RECURSIVE THINKING PROCESS STARTING")
+        print("=" * 50)
+        thinking_rounds = self._determine_thinking_rounds(user_input)
+        if verbose:
+            print(f"\n🤔 Thinking... ({thinking_rounds} rounds needed)")
+        # Initial response
+        print("\n=== GENERATING INITIAL RESPONSE ===")
+        messages = self.conversation_history + [{"role": "user", "content": user_input}]
+        current_best = self._call_api(messages, stream=True)
+        print("=" * 50)
+        thinking_history = [{"round": 0, "response": current_best, "selected": True}]
+        # Iterative improvement
+        for round_num in range(1, thinking_rounds + 1):
+            if verbose:
+                print(f"\n=== ROUND {round_num}/{thinking_rounds} ===")
+            # Generate alternatives
+            alternatives = self._generate_alternatives(current_best, user_input)
+            # Store alternatives in history
+            for i, alt in enumerate(alternatives):
+                thinking_history.append({
+                    "round": round_num,
+                    "response": alt,
+                    "selected": False,
+                    "alternative_number": i + 1
+                })
+            # Evaluate and select best
+            new_best, explanation = self._evaluate_responses(user_input, current_best, alternatives)
+            # Update selection in history
+            if new_best != current_best:
+                for item in thinking_history:
+                    if item["round"] == round_num and item["response"] == new_best:
+                        item["selected"] = True
+                        item["explanation"] = explanation
+                current_best = new_best
+                if verbose:
+                    print(f"\n ✓ Selected alternative: {explanation}")
+            else:
+                for item in thinking_history:
+                    if item["selected"] and item["response"] == current_best:
+                        item["explanation"] = explanation
+                        break
+                if verbose:
+                    print(f"\n ✓ Kept current response: {explanation}")
+        # Add to conversation history
+        self.conversation_history.append({"role": "user", "content": user_input})
+        self.conversation_history.append({"role": "assistant", "content": current_best})
+        # Keep conversation history manageable
+        if len(self.conversation_history) > 10:
+            self.conversation_history = self.conversation_history[-10:]
+        print("\n" + "=" * 50)
+        print("🎯 FINAL RESPONSE SELECTED")
+        print("=" * 50)
+        return {
+            "response": current_best,
+            "thinking_rounds": thinking_rounds,
+            "thinking_history": thinking_history
+        }
+    def save_full_log(self, filename: str = None):
+        """Save the full thinking process log."""
+        if filename is None:
+            filename = f"full_thinking_log_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        with open(filename, 'w', encoding='utf-8') as f:
+            json.dump({
+                "conversation": self.conversation_history,
+                "full_thinking_log": self.full_thinking_log,
+                "timestamp": datetime.now().isoformat()
+            }, f, indent=2, ensure_ascii=False)
+        print(f"Full thinking log saved to {filename}")
+    def save_conversation(self, filename: str = None):
+        """Save the conversation and thinking history."""
+        if filename is None:
+            filename = f"chat_history_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        with open(filename, 'w', encoding='utf-8') as f:
+            json.dump({
+                "conversation": self.conversation_history,
+                "timestamp": datetime.now().isoformat()
+            }, f, indent=2, ensure_ascii=False)
+        print(f"Conversation saved to {filename}")
+# For direct use as a script
+if __name__ == "__main__":
+    print("🤖 Enhanced Recursive Thinking Chat")
+    print("=" * 50)
+    # Get API key
+    api_key = input("Enter your OpenRouter API key (or press Enter to use env variable): ").strip()
+    if not api_key:
+        api_key = os.getenv("OPENROUTER_API_KEY")
+        if not api_key:
+            print("Error: No API key provided and OPENROUTER_API_KEY not found in environment")
+            sys.exit(1)
+    # Initialize chat
+    chat = EnhancedRecursiveThinkingChat(api_key=api_key)
+    print("\nChat initialized! Type 'exit' to quit, 'save' to save conversation.")
+    print("The AI will think recursively before each response.\n")
+    while True:
+        user_input = input("You: ").strip()
+        if user_input.lower() == 'exit':
+            break
+        elif user_input.lower() == 'save':
+            chat.save_conversation()
+            continue
+        elif user_input.lower() == 'save full':
+            chat.save_full_log()
+            continue
+        elif not user_input:
+            continue
+        # Get response with thinking process
+        result = chat.think_and_respond(user_input)
+        print(f"\n🤖 AI FINAL RESPONSE: {result['response']}\n")

requirements (16).txt ADDED Viewed

	@@ -0,0 +1,13 @@

+openai
+fastapi==0.104.1
+uvicorn==0.23.2
+pydantic==2.4.2
+python-dotenv==1.0.0
+websockets==11.0.3
+python-multipart==0.0.6
+aiofiles==23.2.1
+httpx==0.25.0
+requests==2.31.0
+asyncio==3.4.3
+uuid==1.30