feat: Implement WebSocket support for chat functionality and refactor chat service

- Added WebSocket endpoint for real-time chat interactions.
- Refactored ChatPage component to utilize WebSocket for sending and receiving messages.
- Updated chat service to handle streaming responses from the LLM agent.
- Introduced error handling for WebSocket connections and message processing.
- Modified Editor_Test to include AppShellWithMenu for better layout.
- Adjusted file path in generar_tree.py for correct directory structure.
- Created llm_chat_endpoint_v1.py and llm_chat_srvc.py for handling chat requests and responses.
- Established logging for WebSocket interactions and errors.

backend/domains/llms/llm_chat_endpoint_v1.py

@@ -0,0 +1,44 @@
+# backend/domains/llm/agent_endpoints.py
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+from fastapi.concurrency import run_in_threadpool
+
+from backend.domains.llms.llm_chat_srvc import construir_agente_llm, responder, responder_stream
+from src.Logger.logger_db import LoggerDB, logger
+from entrypoint.init_db import db_credencial
+
+LoggerDB(db_credencial, "logger_llm", created_by="sistema")
+
+router = APIRouter()
+agente = construir_agente_llm()  # inicializa el agente una vez
+
+# 📥 Schema para entrada de prompt
+class ChatInput(BaseModel):
+    prompt: str
+
+# ✅ Endpoint de respuesta simple
+@router.post("/chat", summary="Enviar prompt y obtener respuesta completa del agente")
+async def chat_endpoint(data: ChatInput):
+    try:
+        return await responder(data.prompt, agente)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.exception("[ERROR] Fallo durante respuesta del agente:")
+        raise HTTPException(status_code=500, detail="Error interno al procesar la solicitud.")
+
+# 🔁 Endpoint de streaming
+@router.post("/chat-stream", summary="Enviar prompt y recibir respuesta del agente en streaming")
+async def chat_stream_endpoint(data: ChatInput):
+    try:
+        return StreamingResponse(
+            responder_stream(data.prompt, agente),
+            media_type="text/plain"
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.exception("[ERROR] Fallo durante respuesta en streaming:")
+        raise HTTPException(status_code=500, detail="Error interno en el agente.")

backend/domains/llms/llm_chat_srvc.py

@@ -0,0 +1,84 @@
+# src/services/agent_service.py
+
+from src.ApiKeys.openai_apikey_mmr import OpenAICredencialRepo
+from src.ConexionSql.Postgres_conexion import PostgresConexion
+from src.ConexionApis.OpenAi_conexion import OpenAICliente
+from src.Llms.Modelos.Openai_model import ModeloOpenAI
+from src.Llms.Agente import AgenteAI
+from src.Llms.Memory.postgres_MemoryConv import MemoryConvPostgres
+from src.Llms.MCPs.McpClient import MCPClient
+from src.Llms.MCPs.McpClient_Registry import ClientRegistry
+from entrypoint.init_db import db_credencial
+
+from src.Logger.logger_db import LoggerDB, logger
+LoggerDB(db_credencial, "logger_llm", created_by="sistema")
+
+from typing import AsyncGenerator
+
+# 🔧 Inicialización única del agente
+def construir_agente_llm() -> AgenteAI:
+    logger.info("[INICIO] Inicializando agente LLM...")
+
+    conexion = PostgresConexion(db_credencial)
+
+    # Paso 1: Obtener credencial
+    repo = OpenAICredencialRepo(conexion)
+    credencial = repo.get_by_id("OPAK20250513-61b29978b7604031014")
+    if not credencial:
+        raise ValueError("No se encontró la credencial OpenAI")
+
+    logger.debug(f"[OK] Credencial OpenAI cargada: {credencial.titulo}")
+
+    # Paso 2: Crear cliente
+    cliente = OpenAICliente(credencial)
+
+    # Paso 3: Instanciar modelo
+    modelo = ModeloOpenAI(
+        cliente=cliente,
+        model="gpt-4o",
+        temperature=1
+    )
+
+    # Paso 4: Memoria en PostgreSQL
+    memoria = MemoryConvPostgres(
+        credencial=db_credencial,
+        nombre_tabla="memoria_conversacion_pruebas",
+        k=10
+    )
+
+    # Paso 5: Herramientas MCP (ej. archivos)
+    archivos = MCPClient.from_http(
+        name="files",
+        url="http://127.0.0.1:4201/fs"
+    )
+    registry = ClientRegistry()
+    registry.add("files", archivos)
+
+    # Paso 6: Agente
+    agente = AgenteAI(
+        modelo=modelo,
+        nombre="Asistente Inteligente",
+        descripcion="",
+        system_prompt="",
+        rol="asistente",
+        objetivos=[],
+        max_iterations=0,
+        memoria=memoria,
+        mcp=registry
+    )
+
+    logger.success("[OK] Agente LLM listo.")
+    return agente
+
+# ⚡ Función simple
+async def responder(prompt: str, agente: AgenteAI) -> str:
+    logger.info(f"[Petición] Prompt recibido: {prompt[:50]}...")
+    respuesta = await agente.interactuar_en_bucle(prompt=prompt, stream=False)
+    logger.debug(f"[Respuesta] {respuesta[:100]}...")
+    return respuesta
+
+# 🔁 Función en streaming
+async def responder_stream(prompt: str, agente: AgenteAI) -> AsyncGenerator[str, None]:
+    logger.info(f"[Streaming] Prompt recibido: {prompt[:50]}...")
+    async for token in agente.interactuar_en_bucle(prompt=prompt, stream=True):
+        yield token

backend/domains/llms/llm_chat_ws_endpoint_v1.py

@@ -0,0 +1,35 @@
+from fastapi import WebSocket, APIRouter, WebSocketDisconnect
+from backend.domains.llms.llm_chat_srvc import construir_agente_llm
+from src.Logger.logger_db import LoggerDB, logger
+from entrypoint.init_db import db_credencial
+import json
+
+LoggerDB(db_credencial, "logger_llm_ws", created_by="sistema")
+
+router = APIRouter()
+agente = construir_agente_llm()
+
+@router.websocket("/ws/chat")
+async def chat_ws(websocket: WebSocket):
+    await websocket.accept()
+    try:
+        data = await websocket.receive_text()
+        parsed = json.loads(data)
+        prompt = parsed.get("prompt")
+        if not prompt:
+            await websocket.send_text("⚠️ Prompt vacío.")
+            await websocket.close()
+            return
+
+        # ✅ Solución: hacer await antes de iterar
+        respuesta_gen = await agente.interactuar_en_bucle(prompt=prompt, stream=True)
+        async for token in respuesta_gen:
+            await websocket.send_text(token)
+
+        await websocket.close()
+
+    except WebSocketDisconnect:
+        logger.info("🔌 WebSocket desconectado por el cliente.")
+    except Exception as e:
+        logger.exception("❌ Error en WebSocket:")
+        await websocket.close()

backend/main.py

@@ -3,6 +3,8 @@
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from backend.router_v1 import router
+from backend.domains.llms import llm_chat_ws_endpoint_v1
+
 
 app = FastAPI(
     title="Fitz Backend",
@@ -21,4 +23,5 @@ app.add_middleware(
 
 
 # Incluye las rutas de tu API
-app.include_router(router, prefix="/api/v1", tags=["v1"])
+app.include_router(router, prefix="/api/v1", tags=["v1"])
+app.include_router(llm_chat_ws_endpoint_v1.router)

backend/router_v1.py

@@ -4,9 +4,10 @@ from fastapi import APIRouter
 from backend.domains.experiments import charts_examples_endpoint_v1 as charts
 from backend.domains.experiments import ping_endpoint_v1
 from backend.domains.text_manager import text_manager_endpoint_v1
-
+from backend.domains.llms import llm_chat_endpoint_v1
 
 router = APIRouter()
 router.include_router(ping_endpoint_v1.router, prefix="/ping")
 router.include_router(text_manager_endpoint_v1.router, prefix="/text_manager")
 router.include_router(charts.router, prefix="/charts")
+router.include_router(llm_chat_endpoint_v1.router, prefix="/llm", tags=["Agente LLM"])  # ← Nuevo router

frontend/src/domains/Llms/Chat/ChatPage.tsx

@@ -1,4 +1,4 @@
-import { useState } from "react";
+import { useState, useRef } from "react";
 import { Container, Stack, Paper, ScrollArea, Title } from "@mantine/core";
 import { ChatInput } from "./ChatInput";
 import { MessageList } from "./MessageList";
@@ -8,19 +8,42 @@ export function ChatPage() {
   const [messages, setMessages] = useState([
     { sender: "bot", content: "Hola, ¿en qué puedo ayudarte hoy?" },
   ]);
+  const wsRef = useRef<WebSocket | null>(null);
 
   const handleSend = async (content: string) => {
     const newMessages = [...messages, { sender: "user", content }];
     setMessages(newMessages);
 
-    const response = await fetch("/api/chat", {
-      method: "POST",
-      body: JSON.stringify({ messages: newMessages }),
-      headers: { "Content-Type": "application/json" },
-    });
+    let currentResponse = "";
+    setMessages((prev) => [...prev, { sender: "bot", content: "" }]);
 
-    const data = await response.json();
-    setMessages([...newMessages, { sender: "bot", content: data.reply }]);
+    wsRef.current = new WebSocket("ws://localhost:8000/ws/chat");
+
+    wsRef.current.onopen = () => {
+      wsRef.current?.send(JSON.stringify({ prompt: content }));
+    };
+
+    wsRef.current.onmessage = (event) => {
+      const token = event.data;
+      currentResponse += token;
+      setMessages((prev) => {
+        const updated = [...prev];
+        updated[updated.length - 1] = { sender: "bot", content: currentResponse };
+        return updated;
+      });
+    };
+
+    wsRef.current.onerror = (err) => {
+      console.error("WebSocket error:", err);
+      setMessages((prev) => [
+        ...prev.slice(0, -1),
+        { sender: "bot", content: "⚠️ Error al comunicarse con el servidor." },
+      ]);
+    };
+
+    wsRef.current.onclose = () => {
+      wsRef.current = null;
+    };
   };
 
   return (

frontend/src/domains/TextEditor/Editor_Test.tsx

@@ -2,6 +2,7 @@ import { RichTextEditor } from '@mantine/tiptap';
 import { useEditor } from '@tiptap/react';
 import StarterKit from '@tiptap/starter-kit';
 import '@mantine/tiptap/styles.css';
+import { AppShellWithMenu } from '../FitzStudio/Appshell/Appshell';
 
 export default function EditorTest() {
   const editor = useEditor({
@@ -10,8 +11,9 @@ export default function EditorTest() {
   });
 
   return (
+    
     <div style={{ padding: 40 }}>
-      {editor && (
+      {editor && (    <AppShellWithMenu>
         <RichTextEditor editor={editor}>
           <RichTextEditor.Toolbar sticky stickyOffset={0}>
             <RichTextEditor.ControlsGroup>
@@ -21,7 +23,10 @@ export default function EditorTest() {
           </RichTextEditor.Toolbar>
           <RichTextEditor.Content />
         </RichTextEditor>
+            </AppShellWithMenu>
       )}
     </div>
   );
 }
+
+

scripts/datos_para_llms/generar_tree.py

@@ -27,5 +27,5 @@ def save_tree_to_file(start_path='.', max_depth=2, output_file='tree.txt'):
 
 # Ejemplo de uso:
 # Puedes cambiar estos valores según lo necesites
-save_tree_to_file(start_path=r'E:\Fitz_Studio', max_depth=3, output_file=r'E:\Fitz_Studio\data\files\txt\tree.txt')
+save_tree_to_file(start_path=r'E:\Fitz_Studio\backend', max_depth=3, output_file=r'E:\Fitz_Studio\data\files\txt\tree.txt')