Select a model to use with OpenRouter.
+
+
Conversation History
diff --git a/frontend/src/components/TicTacToe.jsx b/frontend/src/components/TicTacToe.jsx
new file mode 100644
index 0000000..67e849d
--- /dev/null
+++ b/frontend/src/components/TicTacToe.jsx
@@ -0,0 +1,408 @@
+import React, { useState, useEffect } from 'react';
+import { useRecThink } from '../context/RecThinkContext';
+import { Brain, RefreshCw } from 'lucide-react';
+
+const TicTacToe = () => {
+ const {
+ apiKey,
+ model,
+ thinkingSystem,
+ isThinking,
+ sessionId,
+ initializeChat,
+ sendMessage
+ } = useRecThink();
+
+ const [board, setBoard] = useState(Array(9).fill(''));
+ const [currentPlayer, setCurrentPlayer] = useState('X'); // X is user, O is AI
+ const [gameStatus, setGameStatus] = useState('ready'); // ready, playing, won, draw
+ const [winner, setWinner] = useState(null);
+ const [aiThinking, setAiThinking] = useState(false);
+ const [gameHistory, setGameHistory] = useState([]);
+
+ // Initialize game
+ const startGame = () => {
+ setBoard(Array(9).fill(''));
+ setCurrentPlayer('X');
+ setGameStatus('playing');
+ setWinner(null);
+ setGameHistory([]);
+ };
+
+ // Check for winner
+ const checkWinner = (board) => {
+ const lines = [
+ [0, 1, 2], [3, 4, 5], [6, 7, 8], // rows
+ [0, 3, 6], [1, 4, 7], [2, 5, 8], // columns
+ [0, 4, 8], [2, 4, 6] // diagonals
+ ];
+
+ for (let i = 0; i < lines.length; i++) {
+ const [a, b, c] = lines[i];
+ if (board[a] && board[a] === board[b] && board[a] === board[c]) {
+ return board[a];
+ }
+ }
+
+ return null;
+ };
+
+ // Check for draw
+ const checkDraw = (board) => {
+ return board.every(cell => cell !== '');
+ };
+
+ // Make a move
+ const handleCellClick = (index) => {
+ if (!apiKey) {
+ alert("Please set your API key in settings first");
+ return;
+ }
+
+ if (board[index] !== '' || gameStatus !== 'playing' || currentPlayer !== 'X' || aiThinking) {
+ return;
+ }
+
+ // Update board with user's move
+ const newBoard = [...board];
+ newBoard[index] = 'X';
+ setBoard(newBoard);
+
+ // Create a new history array with the player's move
+ const updatedHistory = [...gameHistory, { player: 'X', position: index }];
+ setGameHistory(updatedHistory);
+
+ // Check for win or draw
+ const playerWon = checkWinner(newBoard);
+ const isDraw = checkDraw(newBoard);
+
+ if (playerWon) {
+ setGameStatus('won');
+ setWinner('X');
+ return;
+ }
+
+ if (isDraw) {
+ setGameStatus('draw');
+ return;
+ }
+
+ // Switch to AI's turn
+ setCurrentPlayer('O');
+ getAIMove(newBoard);
+ };
+
+ // Get AI move using recursive thinking
+ const getAIMove = async (currentBoard) => {
+ try {
+ setAiThinking(true);
+
+ // Ensure session is initialized
+ if (!sessionId) {
+ try {
+ await initializeChat();
+ // If initialization fails, we'll catch it below
+ } catch (initError) {
+ console.error("Failed to initialize chat:", initError);
+ alert("Failed to connect to AI. Please check your API key in settings.");
+ setGameStatus('ready');
+ setAiThinking(false);
+ return;
+ }
+ }
+
+ // Format the board for the AI
+ const gameState = {
+ board: [
+ [currentBoard[0] || ' ', currentBoard[1] || ' ', currentBoard[2] || ' '],
+ [currentBoard[3] || ' ', currentBoard[4] || ' ', currentBoard[5] || ' '],
+ [currentBoard[6] || ' ', currentBoard[7] || ' ', currentBoard[8] || ' ']
+ ],
+ history: gameHistory
+ };
+
+ // Ask AI for the next move using the chosen thinking system
+ const prompt = `I'm playing Tic Tac Toe. You are playing as O. Here's the current board state (spaces are empty cells):
+
+${gameState.board[0][0]}|${gameState.board[0][1]}|${gameState.board[0][2]}
+-+-+-
+${gameState.board[1][0]}|${gameState.board[1][1]}|${gameState.board[1][2]}
+-+-+-
+${gameState.board[2][0]}|${gameState.board[2][1]}|${gameState.board[2][2]}
+
+The positions are numbered as follows:
+0|1|2
+3|4|5
+6|7|8
+
+Based on this board state, what is your next move? Answer with only a single number 0-8.`;
+
+ let result;
+ try {
+ result = await sendMessage(prompt);
+ } catch (sendError) {
+ console.error("Failed to get AI response:", sendError);
+ alert("Failed to get AI move. The server might be down or your API key may be invalid.");
+ setCurrentPlayer('X');
+ setAiThinking(false);
+ return;
+ }
+
+ if (!result || !result.response) {
+ console.error("Received empty response from AI");
+ setCurrentPlayer('X');
+ setAiThinking(false);
+ return;
+ }
+
+ // Extract move from AI response
+ let aiMoveIndex = -1;
+ const responseText = result.response;
+
+ // Try different regex patterns to extract a valid move
+ const exactNumberPattern = /^\s*([0-8])\s*$/;
+ const numbersInResponse = responseText.match(/\b[0-8]\b/g);
+
+ // First try to find a standalone number
+ const exactMatch = responseText.match(exactNumberPattern);
+ if (exactMatch) {
+ aiMoveIndex = parseInt(exactMatch[1], 10);
+ }
+ // Then try to find any number 0-8 in the response
+ else if (numbersInResponse && numbersInResponse.length > 0) {
+ aiMoveIndex = parseInt(numbersInResponse[0], 10);
+ }
+
+ console.log("AI response:", responseText);
+ console.log("Extracted move:", aiMoveIndex);
+
+ // Validate the move
+ if (aiMoveIndex >= 0 && aiMoveIndex <= 8 && currentBoard[aiMoveIndex] === '') {
+ // Valid move, update the board
+ const newBoard = [...currentBoard];
+ newBoard[aiMoveIndex] = 'O';
+ setBoard(newBoard);
+
+ // Create a new history array with the AI's move
+ const updatedHistory = [...gameHistory, { player: 'O', position: aiMoveIndex }];
+ setGameHistory(updatedHistory);
+
+ // Check for win or draw
+ const aiWon = checkWinner(newBoard);
+ const isDraw = checkDraw(newBoard);
+
+ if (aiWon) {
+ setGameStatus('won');
+ setWinner('O');
+ } else if (isDraw) {
+ setGameStatus('draw');
+ } else {
+ // Back to player's turn
+ setCurrentPlayer('X');
+ }
+ } else {
+ // Invalid move, try to find an empty cell
+ console.error("AI returned invalid move:", aiMoveIndex, "for board:", currentBoard);
+
+ // Find any available empty cell as fallback
+ const emptyCells = currentBoard.map((cell, idx) => cell === '' ? idx : -1).filter(idx => idx !== -1);
+
+ if (emptyCells.length > 0) {
+ // Take the first available empty cell
+ const fallbackMove = emptyCells[0];
+ const newBoard = [...currentBoard];
+ newBoard[fallbackMove] = 'O';
+ setBoard(newBoard);
+
+ // Create a new history array with the fallback move
+ const updatedHistory = [...gameHistory, { player: 'O', position: fallbackMove }];
+ setGameHistory(updatedHistory);
+
+ console.log("Using fallback move:", fallbackMove);
+
+ // Check for win or draw
+ const aiWon = checkWinner(newBoard);
+ const isDraw = checkDraw(newBoard);
+
+ if (aiWon) {
+ setGameStatus('won');
+ setWinner('O');
+ } else if (isDraw) {
+ setGameStatus('draw');
+ } else {
+ setCurrentPlayer('X');
+ }
+ } else {
+ // No empty cells left, it's a draw
+ setGameStatus('draw');
+ }
+ }
+ } catch (error) {
+ console.error("Error in AI move processing:", error);
+ alert("An error occurred while processing the AI move. Please try again.");
+ // Let player try again
+ setCurrentPlayer('X');
+ } finally {
+ setAiThinking(false);
+ }
+ };
+
+ // Game status message
+ const getStatusMessage = () => {
+ if (!apiKey) return "Set your API key in settings to play";
+ if (gameStatus === 'ready') return "Press Start to play";
+ if (gameStatus === 'playing' && currentPlayer === 'X') return "Your turn";
+ if (gameStatus === 'playing' && currentPlayer === 'O') return "AI is thinking...";
+ if (gameStatus === 'won') return `${winner === 'X' ? 'You' : 'AI'} won!`;
+ if (gameStatus === 'draw') return "It's a draw!";
+ return "";
+ };
+
+ // Highlight winning cells
+ const isWinningCell = (index) => {
+ if (gameStatus !== 'won' || !winner) return false;
+
+ const lines = [
+ [0, 1, 2], [3, 4, 5], [6, 7, 8], // rows
+ [0, 3, 6], [1, 4, 7], [2, 5, 8], // columns
+ [0, 4, 8], [2, 4, 6] // diagonals
+ ];
+
+ for (let i = 0; i < lines.length; i++) {
+ const [a, b, c] = lines[i];
+ if (board[a] && board[a] === board[b] && board[a] === board[c] && board[a] === winner) {
+ return lines[i].includes(index);
+ }
+ }
+
+ return false;
+ };
+
+ // Render a single cell
+ const renderCell = (index) => {
+ const winningCell = isWinningCell(index);
+
+ return (
+
handleCellClick(index)}
+ >
+ {board[index]}
+
+ );
+ };
+
+ // Render the board
+ const renderBoard = () => {
+ return (
+
+ {[...Array(9)].map((_, index) => renderCell(index))}
+
+ );
+ };
+
+ // Display winner information
+ const renderWinnerInfo = () => {
+ if (!winner || gameStatus !== 'won') return null;
+
+ return (
+
+
+ {winner === 'X' ? 'You won!' : 'AI won!'}
+
+
+ {winner === 'X'
+ ? 'Congratulations! You beat the AI.'
+ : `The ${thinkingSystem === 'necort' ? 'NECoRT' : 'CoRT'} AI outplayed you.`}
+
+
+ );
+ };
+
+ return (
+
+
Tic Tac Toe
+
+
+
+ Thinking System:
+
+
+ {thinkingSystem === 'necort' ? 'NECoRT' : 'CoRT'}
+
+
+
+ Model:
+
+ {model.split('/')[1]}
+
+
+
+
+
+ {sessionId ? 'Connected' : 'Not connected'}
+
+
+
+
+ {!apiKey && (
+
+
API Key Required
+
Go to the Settings tab to enter your OpenRouter API key
+
+ )}
+
+
+
+
+ {getStatusMessage()}
+
+ {aiThinking && (
+
+
+ AI is thinking with {thinkingSystem === 'necort' ? 'Nash Equilibrium' : 'standard'} recursive thinking...
+
+ )}
+
+
+ {renderBoard()}
+
+ {renderWinnerInfo()}
+
+
+
+
+
+
+ {gameStatus === 'won' && (
+
+
Game Stats
+
+ Winner: {winner === 'X' ? 'Human (X)' : 'AI (O)'}
+
+
+ Thinking System: {thinkingSystem === 'necort' ? 'NECoRT' : 'CoRT'}
+
+
+ Model: {model.split('/')[1]}
+
+
+ )}
+
+ );
+};
+
+export default TicTacToe;
\ No newline at end of file
diff --git a/frontend/src/context/RecThinkContext.js b/frontend/src/context/RecThinkContext.js
index 133cf93..66df12a 100644
--- a/frontend/src/context/RecThinkContext.js
+++ b/frontend/src/context/RecThinkContext.js
@@ -15,22 +15,53 @@ export const RecThinkProvider = ({ children }) => {
const [model, setModel] = useState('mistralai/mistral-small-3.1-24b-instruct:free');
const [thinkingRounds, setThinkingRounds] = useState('auto');
const [alternativesPerRound, setAlternativesPerRound] = useState(3);
+ const [thinkingSystem, setThinkingSystem] = useState('necort'); // 'necort' or 'recthink'
const [error, setError] = useState(null);
const [showThinkingProcess, setShowThinkingProcess] = useState(false);
const [sessions, setSessions] = useState([]);
const [websocket, setWebsocket] = useState(null);
const [connectionStatus, setConnectionStatus] = useState('disconnected');
+ // Load settings from localStorage on init
+ useEffect(() => {
+ try {
+ const savedApiKey = localStorage.getItem('recthink_api_key');
+ const savedModel = localStorage.getItem('recthink_model');
+ const savedThinkingSystem = localStorage.getItem('recthink_thinking_system');
+
+ if (savedApiKey) setApiKey(savedApiKey);
+ if (savedModel) setModel(savedModel);
+ if (savedThinkingSystem) setThinkingSystem(savedThinkingSystem);
+ } catch (err) {
+ console.error('Error loading saved settings', err);
+ }
+ }, []);
+
+ // Save settings to localStorage when they change
+ useEffect(() => {
+ try {
+ if (apiKey) localStorage.setItem('recthink_api_key', apiKey);
+ if (model) localStorage.setItem('recthink_model', model);
+ localStorage.setItem('recthink_thinking_system', thinkingSystem);
+ } catch (err) {
+ console.error('Error saving settings', err);
+ }
+ }, [apiKey, model, thinkingSystem]);
+
// Initialize chat session
const initializeChat = async () => {
try {
setError(null);
- const result = await api.initializeChat(apiKey, model);
+ const result = await api.initializeChat(apiKey, model, thinkingSystem);
setSessionId(result.session_id);
// Initialize with welcome message
setMessages([
- { role: 'assistant', content: 'Welcome to RecThink! I use recursive thinking to provide better responses. Ask me anything.' }
+ { role: 'assistant', content: `Welcome to ${thinkingSystem === 'necort' ? 'NECoRT' : 'CoRT'}! ${
+ thinkingSystem === 'necort'
+ ? 'I use Nash Equilibrium Chain of Recursive Thoughts to provide optimal responses.'
+ : 'I use Chain of Recursive Thoughts to provide better responses.'
+ } Ask me anything.` }
]);
// Set up WebSocket connection
@@ -65,7 +96,8 @@ export const RecThinkProvider = ({ children }) => {
// Send message via API
const result = await api.sendMessage(sessionId, content, {
thinkingRounds: rounds,
- alternativesPerRound
+ alternativesPerRound,
+ thinkingSystem
});
// Update conversation with assistant's response
@@ -189,6 +221,7 @@ export const RecThinkProvider = ({ children }) => {
model,
thinkingRounds,
alternativesPerRound,
+ thinkingSystem,
error,
showThinkingProcess,
sessions,
@@ -199,6 +232,7 @@ export const RecThinkProvider = ({ children }) => {
setModel,
setThinkingRounds,
setAlternativesPerRound,
+ setThinkingSystem,
setShowThinkingProcess,
// Actions
diff --git a/nash_recursive_thinking.py b/nash_recursive_thinking.py
new file mode 100644
index 0000000..982d093
--- /dev/null
+++ b/nash_recursive_thinking.py
@@ -0,0 +1,270 @@
+from recursive_thinking_ai import EnhancedRecursiveThinkingChat
+import numpy as np
+from typing import List, Dict, Tuple
+import json
+
+class NashEquilibriumRecursiveChat(EnhancedRecursiveThinkingChat):
+ """
+ NECoRT: Nash-Equilibrium Chain of Recursive Thoughts
+
+ This extension implements Nash Equilibrium concepts to find an optimal
+ response set where no agent would unilaterally change their strategy.
+ """
+
+ def __init__(self, api_key: str = None, model: str = "mistralai/mistral-small-3.1-24b-instruct:free",
+ num_agents: int = 3, convergence_threshold: float = 0.05):
+ """Initialize with OpenRouter API and Nash Equilibrium parameters."""
+ super().__init__(api_key, model)
+ self.num_agents = num_agents
+ self.convergence_threshold = convergence_threshold
+ self.utility_matrix = None
+ self.nash_equilibrium_log = []
+
+ def _evaluate_response_utility(self, prompt: str, responses: List[str]) -> np.ndarray:
+ """
+ Create a utility matrix where each element [i,j] represents how agent i
+ rates the response from agent j.
+ """
+ n = len(responses)
+ utility_matrix = np.zeros((n, n))
+
+ for i in range(n):
+ for j in range(n):
+ if i == j: # Self-evaluation is biased, set to 0
+ continue
+
+ eval_prompt = f"""Original message: {prompt}
+
+I am evaluating multiple responses. Rate this response from 0-10 (10 being best):
+
+Response being rated: {responses[j]}
+
+Consider accuracy, relevance, clarity, and completeness.
+Respond with ONLY a single number from 0-10."""
+
+ messages = [{"role": "user", "content": eval_prompt}]
+ evaluation = self._call_api(messages, temperature=0.1, stream=False)
+
+ try:
+ score = float(''.join(filter(str.isdigit, evaluation.split('.')[0])))
+ utility_matrix[i, j] = min(score, 10) # Ensure max is 10
+ except:
+ utility_matrix[i, j] = 5 # Default to neutral if parsing fails
+
+ return utility_matrix
+
+ def _find_nash_equilibrium(self, utility_matrix: np.ndarray) -> List[int]:
+ """
+ Find the Nash Equilibrium in the utility matrix.
+ Returns indices of responses that are part of the equilibrium.
+ """
+ n = utility_matrix.shape[0]
+
+ # For each agent, find their best response to others
+ best_responses = []
+ for i in range(n):
+ # Each agent's utility for each response
+ agent_utilities = utility_matrix[i, :]
+ best_response = np.argmax(agent_utilities)
+ best_responses.append(best_response)
+
+ # Find responses that are mutual best responses
+ equilibrium_indices = []
+ for i in range(n):
+ is_equilibrium = True
+ for j in range(n):
+ if j != i and best_responses[j] != i:
+ is_equilibrium = False
+ break
+
+ if is_equilibrium:
+ equilibrium_indices.append(i)
+
+ # If no pure Nash equilibrium is found, return the response with highest average utility
+ if not equilibrium_indices:
+ avg_utilities = np.mean(utility_matrix, axis=0)
+ equilibrium_indices = [np.argmax(avg_utilities)]
+
+ return equilibrium_indices
+
+ def think_and_respond(self, user_input: str, verbose: bool = True) -> Dict:
+ """Process user input with Nash Equilibrium recursive thinking."""
+ print("\n" + "=" * 50)
+ print("๐ค NASH EQUILIBRIUM RECURSIVE THINKING PROCESS STARTING")
+ print("=" * 50)
+
+ thinking_rounds = self._determine_thinking_rounds(user_input)
+
+ if verbose:
+ print(f"\n๐ค Thinking... ({thinking_rounds} rounds needed)")
+
+ # Generate initial responses from each agent
+ print("\n=== GENERATING INITIAL RESPONSES FROM ALL AGENTS ===")
+ agent_responses = []
+ messages = self.conversation_history + [{"role": "user", "content": user_input}]
+
+ for i in range(self.num_agents):
+ temperature = 0.7 + (i * 0.1) # Vary temperature to get diverse responses
+ response = self._call_api(messages, temperature=temperature, stream=True)
+ agent_responses.append(response)
+ print(f"\nAgent {i+1} initial response complete.")
+ print("=" * 50)
+
+ nash_thinking_history = [{
+ "round": 0,
+ "agent_responses": agent_responses.copy(),
+ "equilibrium_indices": [],
+ "utility_matrix": None
+ }]
+
+ # Iterative improvement and equilibrium finding
+ converged = False
+ for round_num in range(1, thinking_rounds + 1):
+ if verbose:
+ print(f"\n=== ROUND {round_num}/{thinking_rounds} ===")
+
+ if converged:
+ print("Nash Equilibrium converged. Stopping early.")
+ break
+
+ # Evaluate utility of each response for each agent
+ utility_matrix = self._evaluate_response_utility(user_input, agent_responses)
+
+ if verbose:
+ print("\nUtility Matrix:")
+ print(utility_matrix)
+
+ # Find Nash Equilibrium
+ equilibrium_indices = self._find_nash_equilibrium(utility_matrix)
+
+ if verbose:
+ print(f"\nNash Equilibrium Indices: {equilibrium_indices}")
+
+ # Check if we've converged
+ if round_num > 1:
+ prev_matrix = nash_thinking_history[-1]["utility_matrix"]
+ if prev_matrix is not None:
+ diff = np.mean(np.abs(utility_matrix - prev_matrix))
+ if diff < self.convergence_threshold:
+ converged = True
+ print(f"\nConverged with difference: {diff:.4f}")
+
+ # Generate improved responses based on utility
+ if not converged:
+ for i in range(self.num_agents):
+ # Agent improves by learning from responses with high utility
+ highest_utility_response_idx = np.argmax(utility_matrix[i, :])
+ highest_utility_response = agent_responses[highest_utility_response_idx]
+
+ improve_prompt = f"""Original message: {user_input}
+
+Highly rated response: {highest_utility_response}
+
+Your current response: {agent_responses[i]}
+
+Improve your response by learning from the highly rated response while maintaining your unique perspective.
+Improved response:"""
+
+ improve_messages = [{"role": "user", "content": improve_prompt}]
+ improved_response = self._call_api(improve_messages, temperature=0.5, stream=True)
+ agent_responses[i] = improved_response
+
+ # Store history
+ nash_thinking_history.append({
+ "round": round_num,
+ "agent_responses": agent_responses.copy(),
+ "equilibrium_indices": equilibrium_indices,
+ "utility_matrix": utility_matrix.tolist() if utility_matrix is not None else None
+ })
+
+ # Select final response from equilibrium
+ final_round = nash_thinking_history[-1]
+ equilibrium_indices = final_round["equilibrium_indices"]
+
+ if not equilibrium_indices:
+ # If no equilibrium, use response with highest average utility
+ utility_matrix = np.array(final_round["utility_matrix"])
+ avg_utilities = np.mean(utility_matrix, axis=0)
+ final_response_idx = np.argmax(avg_utilities)
+ else:
+ # If multiple equilibria, choose the one with highest overall utility
+ if len(equilibrium_indices) > 1:
+ utility_matrix = np.array(final_round["utility_matrix"])
+ avg_utilities = np.mean(utility_matrix, axis=0)
+ max_utility = -1
+ final_response_idx = equilibrium_indices[0]
+
+ for idx in equilibrium_indices:
+ if avg_utilities[idx] > max_utility:
+ max_utility = avg_utilities[idx]
+ final_response_idx = idx
+ else:
+ final_response_idx = equilibrium_indices[0]
+
+ final_response = agent_responses[final_response_idx]
+
+ # Add to conversation history
+ self.conversation_history.append({"role": "user", "content": user_input})
+ self.conversation_history.append({"role": "assistant", "content": final_response})
+
+ # Add to full thinking log
+ self.full_thinking_log.append({
+ "timestamp": datetime.now().isoformat(),
+ "user_input": user_input,
+ "nash_thinking_history": nash_thinking_history,
+ "final_response": final_response,
+ "final_response_agent": final_response_idx,
+ "thinking_rounds": round_num if converged else thinking_rounds,
+ "converged": converged,
+ "convergence_round": round_num if converged else None
+ })
+
+ return {
+ "response": final_response,
+ "thinking_rounds": round_num if converged else thinking_rounds,
+ "thinking_history": nash_thinking_history,
+ "converged": converged,
+ "convergence_round": round_num if converged else None,
+ "final_response_agent": final_response_idx
+ }
+
+ def save_nash_equilibrium_log(self, filename: str = None):
+ """Save the full Nash Equilibrium thinking log to a file."""
+ if not filename:
+ timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+ filename = f"nash_equilibrium_log_{timestamp}.json"
+
+ with open(filename, 'w') as f:
+ json.dump(self.full_thinking_log, f, indent=2)
+
+ print(f"Nash Equilibrium log saved to {filename}")
+
+# Test function
+def main():
+ from dotenv import load_dotenv
+ load_dotenv()
+
+ api_key = os.getenv("OPENROUTER_API_KEY")
+ if not api_key:
+ print("Error: OPENROUTER_API_KEY environment variable not set")
+ sys.exit(1)
+
+ chat = NashEquilibriumRecursiveChat(api_key=api_key)
+
+ while True:
+ user_input = input("\n> ")
+ if user_input.lower() in ['exit', 'quit', 'q']:
+ break
+
+ result = chat.think_and_respond(user_input)
+ print("\n๐ค FINAL RESPONSE:")
+ print(result["response"])
+
+ # Option to save logs
+ if input("\nSave logs? (y/n): ").lower() == 'y':
+ chat.save_nash_equilibrium_log()
+
+if __name__ == "__main__":
+ import os
+ import sys
+ main()
\ No newline at end of file
diff --git a/necort_web.py b/necort_web.py
new file mode 100644
index 0000000..517c03b
--- /dev/null
+++ b/necort_web.py
@@ -0,0 +1,299 @@
+from fastapi import FastAPI, WebSocket, HTTPException, Depends, Request, WebSocketDisconnect
+from fastapi.responses import JSONResponse, HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import uvicorn
+import json
+import os
+import asyncio
+from datetime import datetime
+from typing import List, Dict, Optional, Any
+import logging
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Import both recursive thinking implementations
+from nash_recursive_thinking import NashEquilibriumRecursiveChat
+from recursive_thinking_ai import EnhancedRecursiveThinkingChat
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="NECoRT API", description="Nash-Equilibrium Chain of Recursive Thoughts")
+
+# 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: Optional[str] = None
+ model: str = "mistralai/mistral-small-3.1-24b-instruct:free"
+ num_agents: int = 3
+ convergence_threshold: float = 0.05
+ thinking_system: str = "necort" # "necort" or "recthink"
+
+class MessageRequest(BaseModel):
+ session_id: str
+ message: str
+ thinking_rounds: Optional[int] = None
+ alternatives_per_round: Optional[int] = 3
+ thinking_system: Optional[str] = None
+
+class SaveRequest(BaseModel):
+ session_id: str
+ filename: Optional[str] = None
+ full_log: bool = False
+
+@app.post("/api/initialize")
+async def initialize_chat(config: ChatConfig):
+ """Initialize a new session with NECoRT or standard recursive thinking"""
+ try:
+ # Generate a session ID
+ timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
+ session_id = f"{config.thinking_system}_{timestamp}_{os.urandom(4).hex()}"
+
+ # Use API key from environment if not provided in the request
+ api_key = config.api_key or os.getenv("OPENROUTER_API_KEY")
+ if not api_key:
+ raise ValueError("No API key provided. Please set OPENROUTER_API_KEY in .env file or provide it in the request.")
+
+ # Initialize the appropriate chat instance based on the thinking system
+ if config.thinking_system == "necort":
+ # Nash Equilibrium Chain of Recursive Thoughts
+ chat = NashEquilibriumRecursiveChat(
+ api_key=api_key,
+ model=config.model,
+ num_agents=config.num_agents,
+ convergence_threshold=config.convergence_threshold
+ )
+ system_type = "NECoRT - Nash Equilibrium Chain of Recursive Thoughts"
+ else:
+ # Standard Chain of Recursive Thoughts
+ chat = EnhancedRecursiveThinkingChat(
+ api_key=api_key,
+ model=config.model
+ )
+ system_type = "CoRT - Chain of Recursive Thoughts"
+
+ chat_instances[session_id] = chat
+
+ return {
+ "session_id": session_id,
+ "status": "initialized",
+ "system_type": system_type
+ }
+ 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]
+
+ # Handle system switching if requested
+ if request.thinking_system and request.thinking_system in ["necort", "recthink"]:
+ if (isinstance(chat, NashEquilibriumRecursiveChat) and request.thinking_system == "recthink") or \
+ (isinstance(chat, EnhancedRecursiveThinkingChat) and not isinstance(chat, NashEquilibriumRecursiveChat) and request.thinking_system == "necort"):
+ # Need to switch system - create a new instance with the same API key and model
+ api_key = chat.api_key
+ model = chat.model
+
+ if request.thinking_system == "necort":
+ # Switch to Nash Equilibrium
+ chat = NashEquilibriumRecursiveChat(api_key=api_key, model=model)
+ else:
+ # Switch to standard recursive thinking
+ chat = EnhancedRecursiveThinkingChat(api_key=api_key, model=model)
+
+ # Update the chat instance
+ chat_instances[request.session_id] = chat
+
+ # Override thinking rounds if provided
+ original_thinking_fn = chat._determine_thinking_rounds
+
+ if request.thinking_rounds is not None:
+ # Override the thinking rounds determination
+ chat._determine_thinking_rounds = lambda _: request.thinking_rounds
+
+ # Set alternatives per round if provided and supported
+ if request.alternatives_per_round is not None and hasattr(chat, 'alternatives_per_round'):
+ chat.alternatives_per_round = request.alternatives_per_round
+
+ # Process the message
+ result = chat.think_and_respond(request.message, verbose=True)
+
+ # Restore original function
+ chat._determine_thinking_rounds = original_thinking_fn
+
+ # Determine system type for response
+ system_type = "NECoRT" if isinstance(chat, NashEquilibriumRecursiveChat) else "CoRT"
+
+ return {
+ "session_id": request.session_id,
+ "response": result["response"],
+ "thinking_rounds": result["thinking_rounds"],
+ "thinking_history": result["thinking_history"],
+ "converged": result.get("converged", False),
+ "convergence_round": result.get("convergence_round"),
+ "final_response_agent": result.get("final_response_agent"),
+ "system_type": system_type
+ }
+ 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]
+
+ filename = request.filename
+ if request.full_log:
+ # Use appropriate save method based on chat type
+ if isinstance(chat, NashEquilibriumRecursiveChat):
+ chat.save_nash_equilibrium_log(filename)
+ else:
+ chat.save_full_log(filename)
+ else:
+ chat.save_conversation(filename)
+
+ return {"status": "saved", "filename": filename}
+ 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")
+async def list_sessions():
+ """List all active chat sessions"""
+ sessions = []
+ for session_id, chat in chat_instances.items():
+ sessions.append({
+ "session_id": session_id,
+ "message_count": len(chat.conversation_history) // 2, # Each message-response pair counts as 2
+ "created_at": session_id.split("_")[1], # Extract timestamp from session ID
+ "is_nash_equilibrium": isinstance(chat, NashEquilibriumRecursiveChat)
+ })
+
+ return {"sessions": sessions}
+
+@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 for streaming thinking process
+@app.websocket("/ws/{session_id}")
+async def websocket_endpoint(websocket: WebSocket, session_id: str):
+ await websocket.accept()
+
+ if session_id not in chat_instances:
+ await websocket.send_json({"error": "Session not found"})
+ await websocket.close()
+ return
+
+ chat = chat_instances[session_id]
+
+ try:
+ # Set up a custom callback to stream thinking process
+ original_call_api = chat._call_api
+
+ async def stream_callback(chunk):
+ await websocket.send_json({"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
+ result = chat.think_and_respond(message_data["content"], verbose=True)
+
+ # Send the final result
+ await websocket.send_json({
+ "type": "final",
+ "response": result["response"],
+ "thinking_rounds": result["thinking_rounds"],
+ "thinking_history": result["thinking_history"],
+ "converged": result.get("converged", False),
+ "convergence_round": result.get("convergence_round", None),
+ "final_response_agent": result.get("final_response_agent", 0)
+ })
+
+ except WebSocketDisconnect:
+ logger.info(f"WebSocket disconnected: {session_id}")
+ except Exception as e:
+ logger.error(f"WebSocket error: {str(e)}")
+ try:
+ await websocket.send_json({"error": str(e)})
+ except:
+ pass
+ finally:
+ # Restore original function
+ if chat and hasattr(chat, '_call_api'):
+ chat._call_api = original_call_api
+
+@app.get("/")
+async def root():
+ return {
+ "name": "NECoRT API",
+ "description": "Nash-Equilibrium Chain of Recursive Thoughts",
+ "version": "1.0.0",
+ "tagline": "Let your thoughts argue, evolve, and stabilize."
+ }
+
+if __name__ == "__main__":
+ # Create the .env file if it doesn't exist
+ if not os.path.exists(".env"):
+ with open(".env", "w") as f:
+ f.write("# Add your OpenRouter API key here\n")
+ f.write("OPENROUTER_API_KEY=\n")
+
+ print("""
+ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+ โ โ
+ โ NECoRT - Nash-Equilibrium Chain of Recursive Thoughts โ
+ โ "Let your thoughts argue, evolve, and stabilize." โ
+ โ โ
+ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+ """)
+
+ print("Starting NECoRT API server...")
+ uvicorn.run(app, host="0.0.0.0", port=8000)
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 0000000..2988e5c
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,290 @@
+{
+ "name": "NECoRT",
+ "lockfileVersion": 3,
+ "requires": true,
+ "packages": {
+ "": {
+ "dependencies": {
+ "axios": "^1.9.0"
+ }
+ },
+ "node_modules/asynckit": {
+ "version": "0.4.0",
+ "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+ "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+ "license": "MIT"
+ },
+ "node_modules/axios": {
+ "version": "1.9.0",
+ "resolved": "https://registry.npmjs.org/axios/-/axios-1.9.0.tgz",
+ "integrity": "sha512-re4CqKTJaURpzbLHtIi6XpDv20/CnpXOtjRY5/CU32L8gU8ek9UIivcfvSWvmKEngmVbrUtPpdDwWDWL7DNHvg==",
+ "license": "MIT",
+ "dependencies": {
+ "follow-redirects": "^1.15.6",
+ "form-data": "^4.0.0",
+ "proxy-from-env": "^1.1.0"
+ }
+ },
+ "node_modules/call-bind-apply-helpers": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+ "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+ "license": "MIT",
+ "dependencies": {
+ "es-errors": "^1.3.0",
+ "function-bind": "^1.1.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/combined-stream": {
+ "version": "1.0.8",
+ "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+ "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+ "license": "MIT",
+ "dependencies": {
+ "delayed-stream": "~1.0.0"
+ },
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/delayed-stream": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+ "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.4.0"
+ }
+ },
+ "node_modules/dunder-proto": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+ "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+ "license": "MIT",
+ "dependencies": {
+ "call-bind-apply-helpers": "^1.0.1",
+ "es-errors": "^1.3.0",
+ "gopd": "^1.2.0"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/es-define-property": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+ "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/es-errors": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+ "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/es-object-atoms": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+ "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+ "license": "MIT",
+ "dependencies": {
+ "es-errors": "^1.3.0"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/es-set-tostringtag": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+ "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+ "license": "MIT",
+ "dependencies": {
+ "es-errors": "^1.3.0",
+ "get-intrinsic": "^1.2.6",
+ "has-tostringtag": "^1.0.2",
+ "hasown": "^2.0.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/follow-redirects": {
+ "version": "1.15.9",
+ "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz",
+ "integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==",
+ "funding": [
+ {
+ "type": "individual",
+ "url": "https://github.com/sponsors/RubenVerborgh"
+ }
+ ],
+ "license": "MIT",
+ "engines": {
+ "node": ">=4.0"
+ },
+ "peerDependenciesMeta": {
+ "debug": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/form-data": {
+ "version": "4.0.2",
+ "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.2.tgz",
+ "integrity": "sha512-hGfm/slu0ZabnNt4oaRZ6uREyfCj6P4fT/n6A1rGV+Z0VdGXjfOhVUpkn6qVQONHGIFwmveGXyDs75+nr6FM8w==",
+ "license": "MIT",
+ "dependencies": {
+ "asynckit": "^0.4.0",
+ "combined-stream": "^1.0.8",
+ "es-set-tostringtag": "^2.1.0",
+ "mime-types": "^2.1.12"
+ },
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/function-bind": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+ "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/get-intrinsic": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+ "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+ "license": "MIT",
+ "dependencies": {
+ "call-bind-apply-helpers": "^1.0.2",
+ "es-define-property": "^1.0.1",
+ "es-errors": "^1.3.0",
+ "es-object-atoms": "^1.1.1",
+ "function-bind": "^1.1.2",
+ "get-proto": "^1.0.1",
+ "gopd": "^1.2.0",
+ "has-symbols": "^1.1.0",
+ "hasown": "^2.0.2",
+ "math-intrinsics": "^1.1.0"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/get-proto": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+ "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+ "license": "MIT",
+ "dependencies": {
+ "dunder-proto": "^1.0.1",
+ "es-object-atoms": "^1.0.0"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/gopd": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+ "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/has-symbols": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+ "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/has-tostringtag": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+ "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+ "license": "MIT",
+ "dependencies": {
+ "has-symbols": "^1.0.3"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/hasown": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+ "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+ "license": "MIT",
+ "dependencies": {
+ "function-bind": "^1.1.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/math-intrinsics": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+ "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/mime-db": {
+ "version": "1.52.0",
+ "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+ "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/mime-types": {
+ "version": "2.1.35",
+ "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+ "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+ "license": "MIT",
+ "dependencies": {
+ "mime-db": "1.52.0"
+ },
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/proxy-from-env": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+ "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+ "license": "MIT"
+ }
+ }
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..9467b64
--- /dev/null
+++ b/package.json
@@ -0,0 +1,5 @@
+{
+ "dependencies": {
+ "axios": "^1.9.0"
+ }
+}
diff --git a/requirements.txt b/requirements.txt
index 7a29061..5decbec 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -5,3 +5,4 @@ pydantic>=1.10.7
python-dotenv>=1.0.0
requests>=2.28.0
openai
+numpy>=1.20.0
diff --git a/start-necort.bat b/start-necort.bat
new file mode 100644
index 0000000..a207a22
--- /dev/null
+++ b/start-necort.bat
@@ -0,0 +1,28 @@
+@echo off
+echo Starting NECoRT (Nash-Equilibrium Chain of Recursive Thoughts)...
+echo.
+
+echo Checking for required Python packages...
+pip install -r requirements.txt --no-cache-dir
+
+echo.
+echo [1/2] Starting Backend API Server with Nash Equilibrium Support...
+start cmd /k "python necort_web.py"
+
+echo [2/2] Starting Frontend Development Server...
+cd frontend
+IF NOT EXIST node_modules (
+ echo Installing frontend dependencies...
+ npm install
+)
+start cmd /k "npm start"
+
+echo.
+echo NECoRT should now be available at:
+echo - Backend API: http://localhost:8000
+echo - Frontend UI: http://localhost:3000
+echo.
+echo "Let your thoughts argue, evolve, and stabilize."
+echo.
+echo Press any key to exit this window...
+pause > nul
\ No newline at end of file