pmomusic/LLM/Docker/app.py

import os
import sys
import glob
import time
import hashlib
import textwrap
import requests
import httpx
import socket
import json
import random
import traceback
from fastapi.responses import StreamingResponse
from fastapi import FastAPI, Query, HTTPException, Request, Body
from langchain_chroma import Chroma
from langchain_ollama import OllamaEmbeddings
from langchain_community.document_loaders import DirectoryLoader, TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from ddgs import DDGS
from unstructured.cleaners.core import clean_extra_whitespace, clean_non_ascii_chars, replace_unicode_quotes
from datetime import datetime, timezone, timedelta
from pydantic import BaseModel, Field, PrivateAttr, ValidationError
from typing import Optional, List, Dict, Any, Union, Literal
from collections import Counter


# --- Configuration via variables d'environnement ---

PERSIST_DIR = os.environ.get("CHROMA_PERSIST_DIR", "/chroma_db")
CACHE_DIR = os.environ.get("RESPONSE_CACHE_DIR", "/response_cache")
GENERATE_MODEL = os.environ.get("GENERATE_MODEL", "deepseek-coder:6.7b-instruct")
CHAT_MODEL = os.environ.get("CHAT_MODEL", GENERATE_MODEL)
EMBED_MODEL = os.environ.get("EMBED_MODEL", "nomic-embed-text:latest")
SRC_PATH=os.environ.get("SRC_PATH", ".")
OLLAMA_HOST = os.environ.get("OLLAMA_HOST", "http://host.docker.internal:11434")
PROG_LANG = os.environ.get("PROG_LANG", "go")

try:
    CHUNCK_SIZE = int(os.environ.get("CHUNCK_SIZE", "300"))
except (ValueError, TypeError):
    CHUNCK_SIZE = 300

try:
    CHUNCK_OVERLAP = int(os.environ.get("CHUNCK_OVERLAP", "50"))
except (ValueError, TypeError):
    CHUNCK_OVERLAP = 50

try:
    QUERY_TIMEOUT = int(os.environ.get("QUERY_TIMEOUT", "120"))
except (ValueError, TypeError):
    QUERY_TIMEOUT = 120

DDGS_SEARCH_ENABLED = True


os.makedirs(PERSIST_DIR, exist_ok=True)
os.makedirs(CACHE_DIR, exist_ok=True)


# --- Nettoyage du code ---
def clean_code_content(content: str) -> str:
    cleaned = replace_unicode_quotes(content)
    cleaned = clean_non_ascii_chars(cleaned)
    cleaned = clean_extra_whitespace(cleaned)
    return cleaned

# --- Cache simple ---
def get_cache_key(question: str) -> str:
    return hashlib.md5(question.encode()).hexdigest()

# --- Hot-reload : hash du code ---
def hash_code_dir(paths: list) -> str:
    m = hashlib.md5()
    for path in paths:
        abs_path = os.path.join("/code", path) if path != "." else "/code"
        for f in glob.glob(f"{abs_path}/**/*.go", recursive=True):
            try:
                with open(f, "rb") as file:
                    m.update(file.read())
            except Exception:
                continue
    return m.hexdigest()

# --- Wrapper Nomic Embeddings ---
from typing import List

class NomicEmbeddingsWrapper(OllamaEmbeddings):
    """Wrapper Ollama pour les embeddings de code, compatible Chroma."""
    _cached_dim: int = PrivateAttr()  # attribut interne non validé par Pydantic

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        # Calcul de la dimension une seule fois
        self._cached_dim = 768 #len(super().embed_query("Hello"))

    def _prefix_text(self, text: str, is_document: bool) -> str:
        """Ajoute un préfixe pour distinguer document vs query."""
        prefix = "search_document: " if is_document else "search_query: "
        return prefix + text

    def embed_documents(self, texts: List[str]) -> List[List[float]]:
        """Embeds documents en ajoutant le préfixe, retourne liste de vecteurs float."""
        prefixed_texts = [self._prefix_text(t, is_document=True) for t in texts]
        embeddings = super().embed_documents(prefixed_texts)
        # Normaliser les embeddings vides pour éviter les erreurs Chroma
        return [e if e else [0.0] * self.model_dimensions for e in embeddings]

    def embed_query(self, text: str) -> List[float]:
        """Embeds une query en ajoutant le préfixe."""
        emb = super().embed_query(self._prefix_text(text, is_document=False))
        # Normaliser embedding vide
        return emb if emb else [0.0] * self.model_dimensions

    @property
    def model_dimensions(self) -> int:
        return self._cached_dim

# --- FastAPI ---
app = FastAPI()

# --- Traitement des chemins ---


src_paths_directories = SRC_PATH.split(":")
if not src_paths_directories:
    src_paths_directories = ["."]

# --- Initialisation ---
vectorstore = None
code_hash = ""

def build_vectorstore():
    global vectorstore, code_hash, src_paths_directories
    print("🔹 Construction du vectorstore ...", file=sys.stderr)
    

    # Hash du code pour hot-reload
    new_hash = hash_code_dir(src_paths_directories)
    if vectorstore and new_hash == code_hash:
        print("🔹 Pas de changement dans /code, utilisation du vectorstore existant", file=sys.stderr)
        return
    code_hash = new_hash

    print(f"  🔹 Programmation language: {PROG_LANG}", file=sys.stderr)
    print(f"  🔹 Chunck size: {CHUNCK_SIZE}", file=sys.stderr)
    print(f"  🔹 Chunck overlap: {CHUNCK_OVERLAP}", file=sys.stderr)
    # Text splitter optimisé Go
    code_splitter = RecursiveCharacterTextSplitter.from_language(
        language=PROG_LANG,
        chunk_size=CHUNCK_SIZE,
        chunk_overlap=CHUNCK_OVERLAP, 
        keep_separator=True 
    )

    all_docs = []
    for path in src_paths_directories:
        abs_path = os.path.join("/code", path) if path != "." else "/code"
        print(f"   🔹 Chargement du code Go depuis: {abs_path}", file=sys.stderr)
        loader = DirectoryLoader(
            abs_path,
            glob="**/*.go",
            loader_cls=TextLoader,
            use_multithreading=True,
            loader_kwargs={'autodetect_encoding': True}
        )
        loaded_docs = loader.load()
        print(f"   🔸 {len(loaded_docs)} fichiers chargés", file=sys.stderr)
        for doc in loaded_docs:
            doc.page_content = clean_code_content(doc.page_content)
        all_docs.extend(loaded_docs)

    print(f"🔹 {len(all_docs)} documents après chargement", file=sys.stderr)

    embedding = NomicEmbeddingsWrapper(model=EMBED_MODEL, base_url=OLLAMA_HOST)

    chat_collection = Chroma.from_documents(
        documents=all_docs,
        embedding=embedding,
        persist_directory=PERSIST_DIR,
        collection_metadata={"hnsw:space": "cosine"},
        collection_name="chat_context"
    )

    splits = code_splitter.split_documents(all_docs)
    print(f"🔹 {len(splits)} chunks créés", file=sys.stderr)

    splits = [doc for doc in splits if doc.page_content.strip()]

    # Ajout des statistiques de longueur du split
    bins=50
    counter = Counter(int(len(split.page_content) / bins) * bins for split in splits)
    print("🔹 Histogramme de la longueur des splits :", file=sys.stderr)
    max_value = max(counter.values())
    for length, count in sorted(counter.items()):
        normalized_count = int((count / max_value) * 50)
        print(f"   {length+1:6}-{length+bins:-6}: { '#' * normalized_count}", file=sys.stderr)

    print(f"🔹 {len(splits)} fragments non vides à intégrer", file=sys.stderr)
    # Créer ou recharger Chroma

    # 2. Vectorstore pour la Génération (splits courts)
    gen_collection = Chroma.from_documents(
        documents=splits,  # Morceaux de 200-400 tokens
        embedding=embedding,
        collection_name="code_completion",
        persist_directory=PERSIST_DIR,
        collection_metadata={"hnsw:space": "cosine"}
    )

    vectorstore = {
        "chat": chat_collection,
        "generate": gen_collection
       }

    print("🔹 Vectorstore créé", file=sys.stderr)

# --- Formatage du contexte ---
def format_context(docs: list) -> str:
    context = []
            
    extraits = {}
    print("🔹 Les fichiers suivants ont été selectionnés:", file=sys.stderr)

    for i, doc in enumerate(docs):
        source = doc.metadata.get('source', 'unknown')
        filename = os.path.basename(source)
        print(f"  🔹 {filename} -- extrait {i+1} --", file=sys.stderr)
        if doc.page_content not in extraits:
            extraits[doc.page_content] = True
            context.append(f"### Fichier: {filename} (Extrait {i+1}) ###")
            context.append(textwrap.indent(doc.page_content, '    '))
            print(f"  🔹 {filename} -- fin extrait {i+1} --", file=sys.stderr)
        else:
            print(f"  🔸 {filename} -- extrait {i+1} duppliqué et éliminé --", file=sys.stderr)

    return "\n\n".join(context)

def format_iso_time_with_ns():
    # 1. Obtenir le timestamp actuel avec nanosecondes
    current_time_ns = time.time_ns()
    
    # 2. Convertir en datetime avec timezone locale
    dt = datetime.fromtimestamp(current_time_ns / 1e9).astimezone()
    
    # 3. Formater avec les nanosecondes et décalage horaire
    # - Extraire les nanosecondes
    nanoseconds = current_time_ns % 10**9
    
    # - Formater la partie datetime de base
    base_format = dt.strftime("%Y-%m-%dT%H:%M:%S")
    
    # - Ajouter les nanosecondes (9 chiffres)
    nano_format = f".{nanoseconds:09d}"
    
    # - Formater le décalage horaire
    utc_offset = dt.utcoffset()
    offset_hours = utc_offset.total_seconds() // 3600
    offset_minutes = (utc_offset.total_seconds() % 3600) // 60
    offset_sign = '-' if offset_hours < 0 else '+'
    offset_format = f"{offset_sign}{abs(int(offset_hours)):02d}:{int(offset_minutes):02d}"
    
    return base_format + nano_format + offset_format


# Modèles Pydantic pour l'API compatible Ollama
class GenerateRequest(BaseModel):
    model: str
    prompt: str
    system: Optional[str] = None
    template: Optional[str] = None
    stream: Optional[bool] = False
    options: Optional[Dict[str, Any]] = None

class ChatMessage(BaseModel):
    role: str
    content: str
    images: Optional[List[str]] = None

class ChatRequest(BaseModel):
    model: str
    messages: List[ChatMessage]
    format: Optional[str] = None
    options: Optional[Dict[str, Any]] = None
    stream: bool = True
    keep_alive: Optional[Union[str, int]] = None  # Modification ici

class EmbeddingRequest(BaseModel):
    model: str
    prompt: str
    options: Optional[Dict[str, Any]] = None

class EmbeddingResponse(BaseModel):
    embedding: List[float]

# Fonctions utilitaires
async def perform_rag_search(mode: Literal["generate", "chat"], prompt: str, k: int = 4) -> str:
    """Effectue une recherche RAG et retourne le contexte"""
    build_vectorstore()
    
    rag_docs = vectorstore[mode].similarity_search(prompt, k=k)
    return format_context(rag_docs) if rag_docs else "Aucun contexte trouvé."

async def perform_web_search(prompt: str, k: int = 2) -> str:
    """Effectue une recherche web et retourne les résultats"""
    if not DDGS_SEARCH_ENABLED:
        return "Recherche web désactivée"
    
    try:
        from ddgs import DDGS
        with DDGS() as ddgs:
            results = list(ddgs.text(prompt, max_results=k))
            print(f"🔹 {len(results)} résultats trouvés sur le web", file=sys.stderr)
            for i, r in enumerate(results):  
                print(f" - {i+1}. {r['title']} : {r['href']}", file=sys.stderr)
            
            web_info = "\n".join(
                f"- [{r['title']}]({r['href']}): {r['body'][:150]}..." 
                for r in results
            ) if results else "Aucun résultat web trouvé."
    except Exception as e:
        return f"Erreur recherche web: {str(e)}"

def build_enhanced_prompt(
                 mode: Literal["generate", "chat"], 
                 question: str,
                 rag_context: str,
                 web_context: str):
    
    if mode == "chat":
        prompt = f"""
# Consigne

Vous êtes un expert en programmation {PROG_LANG}. Répondez à la question en utilisant le contexte fourni (extraits de code) et les informations web si disponibles.
Autant que possible tu indiqueras tes sources, url, nom du fichier source...

# Contexte de la question:

## **Contexte Code (extraits pertinents):**

{rag_context}

## **Informations Web:**

{web_context}

## **Instructions:**
- Répondez de manière concise et précise à la question
- Si la réponse se trouve dans le contexte code, citez le fichier et l'extrait correspondant
- Si vous utilisez les informations web, citez la source
- Si la question est en anglais, répondez en anglais. Sinon, en français
- Pour les extraits de code, conservez le formatage et l'indentation

# **Question** à laquelle tu dois répondre

{question}
"""
    else:
        prompt=f"""
# Consigne

Vous êtes un expert en programmation {PROG_LANG}. Essayer de concevoir un petit bout de code permetant de résoudre la question

# Contexte de la question:

## **Contexte Code (extraits pertinents):**

{rag_context}

## **Instructions:**

- Rédigez les commentaires de code dans la même langue que le code qui vous est fourni. À défaut en anglais.
- Nommez les variables dans la même langue que le code qui vous est fourni. À défaut en anglais.
- Si la question est en anglais, répondez en anglais. Sinon, en français
- Pour les extraits de code, conservez le formatage et l'indentation

# **Question** à laquelle tu dois répondre

{question}
"""

    return prompt

# --- Fonctions utilitaires factorisées ---
async def build_augmented_prompt(
                 mode: Literal["generate", "chat"], 
                 question: str
        ) -> str:
    """Construit un prompt enrichi avec contextes RAG et web"""

    rag_context = await perform_rag_search(mode,question,k= 2 if mode=='chat' else 8)

    if mode == "chat":
        web_context = await perform_web_search(question)
    else:
        web_context = ""

    return build_enhanced_prompt(
        mode=mode,
        question=question,
        rag_context=rag_context,
        web_context=web_context
    )

async def _stream_ollama_response(response: httpx.Response, model_name: str):
    """Générateur pour le streaming de la réponse de chat au format Ollama"""
    start_time = datetime.now(timezone.utc).isoformat()
    async for line in response.aiter_lines():
        if line.strip():
            try:
                chunk = json.loads(line)
                
                # Construction du message conforme à l'API Ollama
                message_chunk = {
                    "model": model_name,
                    "created_at": start_time,
                    "message": {
                        "role": "assistant",
                        "content": chunk.get("message", {}).get("content", "") if "message" in chunk else chunk.get("content", "")
                    },
                    "done": chunk.get("done", False)
                }
                
                # Ajout des champs optionnels
                for field in ["total_duration", "load_duration", "prompt_eval_count", "eval_count"]:
                    if field in chunk:
                        message_chunk[field] = chunk[field]
                
                yield f"data: {json.dumps(message_chunk)}\n\n"
                
            except json.JSONDecodeError:
                yield "event: error\ndata: Invalid JSON chunk\n\n"
    
    yield "event: end\ndata: Stream completed\n\n"


# --- Endpoints API ---
@app.post("/api/generate")
async def generate_endpoint(request_data: GenerateRequest = Body(...)):
    try:
        # Construction du prompt enrichi
        enhanced_prompt = await build_augmented_prompt("generate",request_data.prompt)
        
        # Appel à Ollama
        ollama_payload = {
            "model": GENERATE_MODEL,
            "prompt": enhanced_prompt,
            "stream": request_data.stream,
            "options": request_data.options or {}
        }
        
        async with httpx.AsyncClient() as client:
            response = await client.post(
                f"{OLLAMA_HOST}/api/generate",
                json=ollama_payload,
                timeout=QUERY_TIMEOUT
            )
            response.raise_for_status()
            
            if not request_data.stream:
                return response.json()
            else:
                # --- CORRECTION DU STREAMING ---
                async def generate_stream():
                    """Générateur pour le streaming des résultats"""
                    async for chunk in response.aiter_text():
                        # Transférer directement les chunks
                        yield chunk
                        
                    # Fermeture propre du stream
                    # yield "data: [DONE]\n\n"
                
                # Utilisez text/plain au lieu de text/event-stream
                return StreamingResponse(
                    generate_stream(),
                    media_type="text/plain",
                    headers={
                        "Cache-Control": "no-cache",
                        "Connection": "keep-alive",
                        "X-Accel-Buffering": "no"
                    }
                )
                        
    except httpx.RequestError as e:
        raise HTTPException(500, f"Erreur de connexion à Ollama: {str(e)}")
    except Exception as e:
        raise HTTPException(500, f"Erreur interne: {str(e)}")

@app.post("/api/chat")
async def chat_endpoint(request_data: ChatRequest):
    try:
        messages = [msg.dict() for msg in request_data.messages]
        
        if messages and messages[-1]["role"] == "user":
            original_question = messages[-1]["content"]
            try:
                # Limiter la taille du contexte
                augmented_prompt = await build_augmented_prompt("chat",original_question)
                messages[-1]["content"] = augmented_prompt[-8000:]  # Truncate to the last 8000 chars
                print(f"🔹 Prompt enrichi ({len(augmented_prompt)} caractères)", file=sys.stderr)
            except Exception as e:
                print(f"⚠️ Erreur d'enrichissement: {str(e)}", file=sys.stderr)
                messages[-1]["content"] = original_question  # Fallback to original
        
        # Préparation du payload pour Ollama
        ollama_payload = {
            "model": CHAT_MODEL,
            "messages": messages,
            "stream": request_data.stream,
            "options": request_data.options or {}
        }

        if request_data.keep_alive is not None:
            if isinstance(request_data.keep_alive, int):
                ollama_payload["keep_alive"] = f"{request_data.keep_alive}s"
            else:
                ollama_payload["keep_alive"] = request_data.keep_alive
        
        sopload = json.dumps(ollama_payload, indent=2)
        print(f" 🔹 Taille du Payload vers Ollama : {len(sopload)} octets...", file=sys.stderr)
        print(f" 🔹 Début du payload : {sopload}...", file=sys.stderr)

        # Appel à Ollama
        async with httpx.AsyncClient() as client:
            try:
                response = await client.post(
                    f"{OLLAMA_HOST}/api/chat",
                    json=ollama_payload,
                    timeout=QUERY_TIMEOUT
                )
                response.raise_for_status()
                
                # Gestion des réponses NON-STREAMING
                if not request_data.stream:
                    return response.json()
                
                # --- CORRECTION DU STREAMING ---
                async def generate_stream():
                    """Générateur pour le streaming des résultats"""
                    async for chunk in response.aiter_text():
                        # Transférer directement les chunks
                        yield chunk
                        
                    # Fermeture propre du stream
                    # yield "data: [DONE]\n\n"
                
                # Utilisez text/plain au lieu de text/event-stream
                return StreamingResponse(
                    generate_stream(),
                    media_type="text/plain",
                    headers={
                        "Cache-Control": "no-cache",
                        "Connection": "keep-alive",
                        "X-Accel-Buffering": "no"
                    }
                )
    # ... [gestion des erreurs existante] ...
            except httpx.HTTPStatusError as e:
                error_detail = e.response.text if e.response else str(e)
                print(f"🚨 Erreur HTTP Ollama ({e.response.status_code}): {error_detail}", file=sys.stderr)
                raise HTTPException(502, f"Erreur Ollama: {error_detail}")
            except httpx.RequestError as e:
                print(f"🚨 Erreur réseau Ollama: {str(e)}", file=sys.stderr)
                raise HTTPException(503, f"Ollama non disponible: {str(e)}")
                
    except Exception as e:
        print(f"🚨 Erreur interne: {traceback.format_exc()}", file=sys.stderr)
        raise HTTPException(500, f"Erreur interne: {str(e)}")

@app.post("/api/embeddings")
async def embeddings(request: EmbeddingRequest):
    """Proxy direct pour les embeddings"""
    async with httpx.AsyncClient() as client:
        try:
            response = await client.post(
                f"{OLLAMA_HOST}/api/embeddings",
                json=request.dict()
            )
            response.raise_for_status()
            return response.json()
            
        except httpx.RequestError as e:
            raise HTTPException(500, f"Erreur de connexion à Ollama: {str(e)}")

@app.get("/api/tags")
async def list_models():
    """Proxy pour lister les modèles disponibles"""
    async with httpx.AsyncClient() as client:
        try:
            response = await client.get(f"{OLLAMA_HOST}/api/tags")
            response.raise_for_status()
            return response.json()
            
        except httpx.RequestError as e:
            raise HTTPException(500, f"Erreur de connexion à Ollama: {str(e)}")

# Initialisation du vectorstore (à adapter à votre code)
@app.on_event("startup")
async def startup_event():
    global vectorstore
    build_vectorstore()
    print("🔹 Initialisation du serveur proxy Ollama+RAG")

# Endpoint supplémentaire pour le contrôle
@app.get("/control/enable_web_search")
async def enable_web_search(enabled: bool = True):
    global DDGS_SEARCH_ENABLED
    DDGS_SEARCH_ENABLED = enabled
    return {"status": "success", "web_search_enabled": enabled}

# Endpoint de debug simplifié
@app.post("/debug")
async def debug_endpoint(request: Request):
    """Endpoint de débogage simplifié"""
    try:
        body = await request.json()
        return {
            "status": "success",
            "received_body": body
        }
    except json.JSONDecodeError:
        raise HTTPException(400, "Invalid JSON format")