TEST

app.py

@@ -1,106 +1,16 @@
-import gradio as gr
-from openai import OpenAI
-import os
-import asyncio
-import re
-from mcp import ClientSession
-from mcp.client.stdio import stdio_client
+from mcp.client.session import MCPClient
 
-cle_api = os.environ.get("CLE_API_MISTRAL")
+# Connexion
+client = MCPClient("csv_analyzer")
+client.connect()
 
-# Initialisation du client Mistral (API compatible OpenAI)
-client = OpenAI(api_key=cle_api, base_url="https://api.mistral.ai/v1")
+# Lister les colonnes
+print("Colonnes dispo:", client.call("list_columns"))
 
-def extract_csv_uri_and_question(text: str):
-    """Retourne (uri, question). Si pas de uri, uri == None."""
-    m = re.search(r"(csv://\S+)", text)
-    if not m:
-        return None, text.strip()
-    uri = m.group(1).rstrip(",.;")  # retire ponctuation courante
-    question = text.replace(m.group(1), "").strip()
-    if question == "":
-        question = "Donne un aperçu et un résumé des données."
-    return uri, question
+# Filtrer des lignes
+rows = client.call("filter_rows", column="pays", value="France", limit=3)
+print("Lignes filtrées:", rows)
 
-async def fetch_csv_preview(uri: str) -> str:
-    # Paramètres pour lancer le provider en tant que sous-processus
-    params = {
-        "command": "python",
-        "args": ["csv_provider.py"],
-    }
-    # Création de la session
-    async with ClientSession(stdio_client, params) as session:
-        resp = await session.get_resource(uri)
-        return resp.resource.text
-
-def trim_context(text: str, max_chars: int = 4000) -> str:
-    if not text:
-        return ""
-    if len(text) <= max_chars:
-        return text
-    # garder le début (head) utile pour les CSV preview
-    return text[:max_chars] + "\n... (truncated)"
-
-def call_llm(messages, model="mistral-small-latest", max_tokens=512, temperature=0.2):
-    """Appel synchrones au LLM (OpenAI-compatible)."""
-    resp = client.chat.completions.create(
-        model=model,
-        messages=messages,
-        max_tokens=max_tokens,
-        temperature=temperature,
-    )
-    return resp.choices[0].message["content"].strip()
-
-# --- LOGIQUE DU CHATBOT ---
-def chatbot(message, history):
-    history = history or []
-    history.append(("Vous: " + message, ""))
-
-    uri, question = extract_csv_uri_and_question(message)
-
-    # Préparer prompt system
-    system_prompt = (
-        "Tu es un assistant utile. Si une ressource csv://... est fournie, utilise SON CONTENU "
-        "pour répondre précisément aux questions. Ne devine pas les valeurs absentes. "
-        "Rends la réponse concise et fournis des exemples si pertinent."
-    )
-
-    # Si l'utilisateur demande d'utiliser un CSV -> récupérer via MCP
-    csv_text = None
-    if uri:
-        try:
-            csv_text = asyncio.run(fetch_csv_preview(uri))
-        except Exception as e:
-            reply = f"Erreur de récupération MCP pour {uri} : {e}"
-            history[-1] = (history[-1][0], "Bot: " + reply)
-            return history, history
-
-    # Construire messages pour LLM
-    messages = [{"role": "system", "content": system_prompt}]
-    if csv_text:
-        context = trim_context(csv_text, max_chars=4000)
-        messages.append({"role": "system", "content": f"--- CONTEXTE CSV ({uri}) ---\n{context}\n--- FIN CONTEXTE ---"})
-        user_content = f"Question (en se basant sur le CSV):\n{question}"
-    else:
-        user_content = question
-
-    messages.append({"role": "user", "content": user_content})
-
-    # Appel LLM
-    try:
-        llm_reply = call_llm(messages)
-    except Exception as e:
-        llm_reply = f"Erreur LLM : {e}"
-
-    history[-1] = (history[-1][0], "Bot: " + llm_reply)
-    return history, history
-    
-with gr.Blocks() as demo:
-
-
-    chatbot_ui = gr.Chatbot(label="ChatBot")
-    msg = gr.Textbox(placeholder="Écrivez un message...")
-
-    msg.submit(chatbot, [msg, chatbot_ui], [chatbot_ui, chatbot_ui])
-
-demo.launch()
+# Analyse avec Mistral
+analysis = client.call("analyze_data", question="Quels sont les 3 produits les plus fréquents ?")
+print("Analyse:", analysis)

csv_provider.py

@@ -1,50 +0,0 @@
-import asyncio
-import pandas as pd
-from huggingface_hub import HfApi, hf_hub_download
-from mcp.server import Server
-from mcp.types import Resource, ResourceResponse
-import os
-
-server = Server("csv-provider")
-
-HF_TOKEN = os.environ.get("HF_TOKEN")
-api = HfApi()
-
-# Resource: csv://repo_id/path/to/file.csv
-@server.resource("csv://{repo_id}/{path}")
-async def get_csv(repo_id: str, path: str) -> ResourceResponse:
-    try:
-        # Télécharger le fichier CSV depuis le dataset privé
-        local_path = hf_hub_download(
-            repo_id=repo_id,
-            filename=path,
-            repo_type="dataset",
-            token=HF_TOKEN
-        )
-
-        # Charger et prévisualiser le CSV
-        df = pd.read_csv(local_path)
-        preview = df.head(5).to_string()
-
-        return ResourceResponse(
-            resource=Resource(
-                uri=f"csv://{repo_id}/{path}",
-                name=f"CSV: {path}",
-                description=f"Aperçu des données du dataset {repo_id}",
-                mimeType="text/plain",
-                text=preview,
-            )
-        )
-    except Exception as e:
-        return ResourceResponse(
-            resource=Resource(
-                uri=f"csv://{repo_id}/{path}",
-                name=f"Erreur CSV",
-                description=str(e),
-                mimeType="text/plain",
-                text=f"Impossible de lire {repo_id}/{path} : {e}",
-            )
-        )
-
-if __name__ == "__main__":
-    asyncio.run(server.run())

serveur_mcp.py

@@ -0,0 +1,45 @@
+import pandas as pd
+from datasets import load_dataset
+from transformers import pipeline
+from mcp.server.fastmcp import FastMCPServer
+
+# Charger dataset Hugging Face privé
+dataset = load_dataset("HackathonCRA/2024", split="train")
+df = dataset.to_pandas()
+
+# Charger Mistral
+mistral = pipeline("text-generation", model="mistralai/Mistral-7B-Instruct-v0.2", device_map="auto")
+
+# Créer serveur MCP
+server = FastMCPServer("csv_analyzer")
+
+@server.tool()
+def list_columns() -> list[str]:
+    """Retourne la liste des colonnes disponibles dans le CSV."""
+    return df.columns.tolist()
+
+@server.tool()
+def filter_rows(column: str, value: str, limit: int = 5) -> list[dict]:
+    """Retourne des lignes où column == value."""
+    if column not in df.columns:
+        return [{"error": f"Colonne {column} inexistante"}]
+    subset = df[df[column] == value].head(limit)
+    return subset.to_dict(orient="records")
+
+@server.tool()
+def analyze_data(question: str) -> str:
+    """Interprète les données CSV avec Mistral."""
+    # On résume rapidement le dataframe
+    sample = df.head(20).to_string()
+    prompt = f"""
+    Voici un extrait de données tabulaires :
+    {sample}
+
+    Question: {question}
+    Réponds de manière concise et claire.
+    """
+    output = mistral(prompt, max_new_tokens=256)[0]["generated_text"]
+    return output
+
+if __name__ == "__main__":
+    server.run()