Spaces:

openfree
/

Chain-of-Recursive-Thoughts

Running

App Files Files Community

openfree commited on 18 days ago

Commit

350f1fd

verified ·

1 Parent(s): 1ea0a48

Delete app-backup.py

Browse files

Files changed (1) hide show

app-backup.py +0 -608

app-backup.py DELETED Viewed

@@ -1,608 +0,0 @@
-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="Chain of Recursive Thoughts",
-    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)