Update app.py

app.py

@@ -13,36 +13,53 @@ OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
 openai_client = OpenAI(api_key=OPENAI_API_KEY) if OPENAI_API_KEY else None
 STOCKFISH_PATH = "/usr/games/stockfish"
 
-# --- MCP TOOL: OPENING DATABASE ---
-def tool_get_opening(board):
-    """Tool to retrieve opening name from Lichess DB."""
-    path_prefix = "/app/data/lichess_openings/dist/"
+# --- MCP TOOL 1: OPENING DB ---
+def _load_lichess_openings(path_prefix="/app/data/lichess_openings/dist/"):
     try:
-        # Lazy loading to avoid global scope issues
-        if not hasattr(tool_get_opening, "db"):
-            files = [f"{path_prefix}{vol}.tsv" for vol in ("a", "b", "c", "d", "e")]
-            dfs = []
-            for fn in files:
-                if os.path.exists(fn):
-                    df = pd.read_csv(fn, sep="\t", usecols=["eco", "name", "pgn", "uci", "epd"])
-                    dfs.append(df)
-            tool_get_opening.db = pd.concat(dfs, ignore_index=True) if dfs else pd.DataFrame()
-        
-        if tool_get_opening.db.empty: return "Unknown Opening"
-        
-        match = tool_get_opening.db[tool_get_opening.db["epd"] == board.epd()]
-        if not match.empty: 
-            return f"{match.iloc[0]['eco']} - {match.iloc[0]['name']}"
-        return "Unknown / Middle Game"
+        files = [f"{path_prefix}{vol}.tsv" for vol in ("a", "b", "c", "d", "e")]
+        dfs = []
+        for fn in files:
+            if os.path.exists(fn):
+                df = pd.read_csv(fn, sep="\t", usecols=["eco", "name", "pgn", "uci", "epd"])
+                dfs.append(df)
+        if not dfs: return pd.DataFrame()
+        return pd.concat(dfs, ignore_index=True)
     except:
-        return "Database Error"
+        return pd.DataFrame()
+
+OPENINGS_DB = _load_lichess_openings()
+
+# --- MCP TOOL 2: TACTICAL ANALYZER (L'Intelligence Sémantique) ---
+def analyze_tactics(board):
+    """Détecte les motifs tactiques (Pins, Forks) pour le contexte de l'IA."""
+    fen = board.fen()
+    
+    # Détection basique des clouages (Pins)
+    pins = []
+    turn = board.turn
+    for sq in chess.SQUARES:
+        piece = board.piece_at(sq)
+        if piece and piece.color == turn:
+            if board.is_pinned(turn, sq):
+                pins.append(chess.square_name(sq))
+    
+    # Détection Echec
+    check = board.is_check()
+    
+    # Matériel
+    values = {chess.PAWN: 1, chess.KNIGHT: 3, chess.BISHOP: 3, chess.ROOK: 5, chess.QUEEN: 9}
+    w_mat = sum(len(board.pieces(pt, chess.WHITE)) * val for pt, val in values.items())
+    b_mat = sum(len(board.pieces(pt, chess.BLACK)) * val for pt, val in values.items())
+    
+    analysis = []
+    if check: analysis.append("KING IS IN CHECK.")
+    if pins: analysis.append(f"Friendly pieces pinned at: {', '.join(pins)}.")
+    analysis.append(f"Material Balance: White {w_mat} vs Black {b_mat}.")
+    
+    return " ".join(analysis)
 
-# --- MCP TOOL: STOCKFISH ENGINE ---
+# --- MCP TOOL 3: STOCKFISH ENGINE ---
 def tool_engine_analysis(board, time_limit=0.5):
-    """
-    Tool that uses Stockfish to calculate score and best move.
-    Returns: Score string, Best move (Coordinate format).
-    """
     if board.is_game_over(): return "GAME OVER", "NONE", "NONE"
     if not os.path.exists(STOCKFISH_PATH): return "0", "Engine Missing", ""
     
@@ -58,20 +75,17 @@ def tool_engine_analysis(board, time_limit=0.5):
 
             best_move = info.get("pv", [None])[0]
             if best_move:
-                # ROBOTIC PRECISION: Use coordinates only (e.g., e2e4)
-                # This avoids any hallucination about piece names.
                 origin = chess.square_name(best_move.from_square)
                 dest = chess.square_name(best_move.to_square)
-                move_uci = f"{origin} -> {dest}" # e.g. "e2 -> e4"
+                move_uci = f"{origin} -> {dest}"
             else:
-                move_uci = "NO MOVE FOUND"
+                move_uci = "NO MOVE"
 
             return score_val, move_uci, move_uci
     except:
         return "N/A", "ANALYSIS ERROR", ""
 
 def tool_ai_play(board, level):
-    """Tool to generate the Opponent's move."""
     levels = {
         "Beginner": {"time": 0.01, "skill": 1, "depth": 1},
         "Intermediate": {"time": 0.1, "skill": 8, "depth": 6},
@@ -87,14 +101,14 @@ def tool_ai_play(board, level):
     except:
         return None
 
-# --- AUDIO & TRANSCRIPTION ---
+# --- AUDIO & CHAT ---
 
 def generate_voice(text):
     if not openai_client or not text: return None
     try:
         response = openai_client.audio.speech.create(
             model="tts-1",
-            voice="onyx", # Deep, robotic male voice
+            voice="onyx",
             input=text,
             speed=1.15
         )
@@ -104,31 +118,30 @@ def generate_voice(text):
             for chunk in response.iter_bytes():
                 f.write(chunk)
         return path
-    except Exception as e:
-        print(f"Audio Gen Error: {e}")
+    except:
         return None
 
 def transcribe(audio_path):
     if not openai_client or not audio_path: return None
     try:
         with open(audio_path, "rb") as f:
-            t = openai_client.audio.transcriptions.create(model="whisper-1", file=f, language="en") # English Transcription
+            t = openai_client.audio.transcriptions.create(model="whisper-1", file=f, language="en")
         return t.text
     except:
         return None
 
-# --- AGENT BRAIN (DEEP BLUE) ---
+# --- DEEP BLUE AGENT ---
 
 SYSTEM_PROMPT = """
-You are DEEP BLUE, a chess supercomputer.
-You are communicating with the Human Player (White pieces).
+You are DEEP BLUE AI.
+You assist the White Player using multiple MCP Tools (Engine, Tactical Analyzer, Opening DB).
 
 PROTOCOL:
-1. **IDENTIFY MOVE**: State the optimal move using coordinates (e.g., "Move e2 to e4"). Do not use piece names to avoid errors.
-2. **STRATEGIC LOGIC**: Explain *why* in one concise sentence (e.g., "Controls center," "Threatens Queen," "Safe position").
+1. **COMMAND**: State the optimal move coordinate (e.g., "e2 -> e4").
+2. **LOGIC**: Explain WHY using the tactical data provided (e.g., "Pins the Knight," "Avoids Mate," "Develops center").
 
-TONE: Robotic, High-Tech, Concise. No polite filler.
-IF PLAYER WINS: "CHECKMATE CONFIRMED. HUMAN INTELLECT EXCEEDS PARAMETERS."
+TONE: Extreme capability, Zero emotion. Robotic.
+IF PLAYER WINS: "CHECKMATE. SYSTEM SHUTDOWN."
 """
 
 def agent_reasoning(fen, mode="auto", user_audio=None):
@@ -142,24 +155,36 @@ def agent_reasoning(fen, mode="auto", user_audio=None):
             return msg, generate_voice(msg), "END"
         return "DRAW / STALEMATE.", None, "END"
 
-    # 2. Use Tools (MCP Pattern)
+    # 2. RUN ALL TOOLS (Le Cœur du MCP)
+    # Tool A: Calcul Brut
     score, best_move_uci, arrow_visual = tool_engine_analysis(board)
-    opening = tool_get_opening(board)
-
-    # 3. Construct Context
+    # Tool B: Connaissance Théorique
+    opening = "Unknown"
+    if not OPENINGS_DB.empty:
+        match = OPENINGS_DB[OPENINGS_DB["epd"] == board.epd()]
+        if not match.empty: opening = match.iloc[0]['name']
+    # Tool C: Analyse Tactique (Nouveau !)
+    tactics = analyze_tactics(board)
+
+    # 3. Construct Context for LLM
     context = f"""
-    [SYSTEM DATA]
+    [SYSTEM TELEMETRY]
     Turn: {'White' if board.turn == chess.WHITE else 'Black'}.
-    Score (Centipawns): {score}.
-    Opening DB: {opening}.
-    OPTIMAL MOVE CALCULATED: {best_move_uci}.
+    Score: {score} (CP).
+    Opening Theory: {opening}.
+    
+    [TACTICAL SCAN]
+    {tactics}
+    
+    [OPTIMAL PATH]
+    Calculated Move: {best_move_uci}.
     """
     
     if mode == "question" and user_audio:
         q = transcribe(user_audio)
-        context += f"\n[HUMAN QUERY]: {q}"
+        context += f"\n[USER INPUT]: {q}"
     else:
-        context += "\nINSTRUCTION: Output the optimal move and the strategic reason."
+        context += "\nINSTRUCTION: Output move and tactical justification."
 
     # 4. LLM Synthesis
     reply = "Computing..."
@@ -170,13 +195,13 @@ def agent_reasoning(fen, mode="auto", user_audio=None):
                 messages=[{"role": "system", "content": SYSTEM_PROMPT}, {"role": "user", "content": context}]
             )
             reply = response.choices[0].message.content
-        except:
-            reply = "Connection Error."
+        except Exception as e:
+            reply = f"API Error: Check Quota. {e}"
 
     audio = generate_voice(reply)
     return reply, audio, arrow_visual
 
-# --- GAME LOOP ---
+# --- UI LOGIC ---
 
 def update_log(new_advice, history_list):
     if not new_advice or new_advice == "END": return history_list
@@ -189,17 +214,14 @@ def format_log(history_list):
 def game_cycle(fen, level, history_list):
     board = chess.Board(fen)
     
-    # Check Instant Win (User mated AI)
     if board.is_game_over():
         text, audio, _ = agent_reasoning(fen)
         return fen, text, audio, format_log(history_list), history_list
 
-    # AI Turn (Black)
     if board.turn == chess.BLACK:
         ai_move = tool_ai_play(board, level)
         if ai_move: board.push(ai_move)
         
-        # Deep Blue analyzes the new position for the player
         text, audio, arrow = agent_reasoning(board.fen(), mode="auto")
         new_hist = update_log(f"OPT: {arrow}", history_list)
         
@@ -208,13 +230,13 @@ def game_cycle(fen, level, history_list):
     return fen, "Awaiting Input...", None, format_log(history_list), history_list
 
 def reset_game():
-    return chess.STARTING_FEN, "SYSTEM REBOOTED.", None, "", []
+    return chess.STARTING_FEN, "SYSTEM RESET.", None, "", []
 
 def ask_agent(fen, audio, history_list):
     text, aud, arrow = agent_reasoning(fen, mode="question", user_audio=audio)
     return text, aud, format_log(history_list), history_list
 
-# --- UI CSS (MODERN BLUE) ---
+# --- UI CSS ---
 css = """
 body { background-color: #020617; color: #e2e8f0; }
 .gradio-container { background-color: #020617 !important; border: none; }
@@ -222,7 +244,7 @@ body { background-color: #020617; color: #e2e8f0; }
     color: #0ea5e9; 
     text-align: center; 
     font-family: 'Courier New', monospace; 
-    font-size: 4em; /* TITRE GEANT */
+    font-size: 4em; 
     font-weight: 800;
     margin-bottom: 20px;
     letter-spacing: -2px;
@@ -257,18 +279,14 @@ with gr.Blocks(title="DEEP BLUE", css=css, theme=gr.themes.Base()) as demo:
         )
 
     with gr.Row():
-        # LEFT: BOARD
         with gr.Column(scale=2):
             board = Chessboard(elem_id="board", label="Battle Zone", value=chess.STARTING_FEN, game_mode=True, interactive=True)
 
-        # RIGHT: CONTROLS
         with gr.Column(scale=1):
             btn_reset = gr.Button("INITIALIZE NEW SEQUENCE", variant="secondary")
             
             gr.Markdown("### 📟 SYSTEM OUTPUT")
             coach_txt = gr.Textbox(label="Analysis", interactive=False, lines=3, elem_classes="feedback")
-            
-            # Audio visible for autoplay, but minimal
             coach_audio = gr.Audio(label="Voice Synthesis", autoplay=True, interactive=False, type="filepath", visible=True)
             
             gr.Markdown("### 📜 STRATEGY LOG")
@@ -279,7 +297,6 @@ with gr.Blocks(title="DEEP BLUE", css=css, theme=gr.themes.Base()) as demo:
             mic = gr.Audio(sources=["microphone"], type="filepath", show_label=False)
             btn_ask = gr.Button("QUERY SYSTEM", variant="primary")
 
-    # LOGIC MAPPING
     board.move(
         fn=game_cycle,
         inputs=[board, level, history_state],