Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,484 @@
-import altair as alt
-import numpy as np
-import pandas as pd
+import os
+import json
+import time
+from typing import Any, Dict, List, Optional, Tuple
+
+import requests
 import streamlit as st
+from openai import OpenAI
+
+
+# ----------------------------
+# Helpers
+# ----------------------------
+def get_headers(api_key: str) -> Dict[str, str]:
+    return {"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"}
+
+
+def pretty(obj: Any) -> str:
+    return json.dumps(obj, ensure_ascii=False, indent=2)
+
+def make_client(base_url: str, api_key: str) -> OpenAI:
+    return OpenAI(base_url=base_url, api_key=api_key)
+
+
+def http_get_json(url: str, headers: Dict[str, str], timeout: int = 30) -> Dict[str, Any]:
+    r = requests.get(url, headers=headers, timeout=timeout)
+    r.raise_for_status()
+    return r.json()
+
+
+def http_post_json(url: str, headers: Dict[str, str], payload: Dict[str, Any], timeout: int = 60) -> Dict[str, Any]:
+    r = requests.post(url, headers=headers, json=payload, timeout=timeout)
+    r.raise_for_status()
+    return r.json()
+
+
+def provider_defaults() -> Dict[str, Dict[str, str]]:
+    return {
+        "OpenAI": {
+            "base_url": "https://api.openai.com/v1",
+            "env_key": os.environ.get("OPENAI_API_KEY"),
+            "notes": "Supporte Responses API (web_search, image) + Chat/Embeddings/Models.",
+        },
+        "Groq": {
+            "base_url": "https://api.groq.com/openai/v1",
+            "env_key": os.environ.get("GROQ_API_KEY"),
+            "notes": "OpenAI-compatible pour Chat/Models/Embeddings (selon offre). Pas de web_search OpenAI.",
+        },
+        "Ollama": {
+            "base_url": "https://ollama.com/v1",
+            "env_key": os.environ.get("OLLAMA_API_KEY"),
+            "notes": "OpenAI-compatible local. Models/Chat ok selon config. Embeddings selon modèles dispo.",
+        },
+        "Albert (Etalab)": {
+            "base_url": "https://albert.api.etalab.gouv.fr/v1",
+            "env_key": os.environ.get("ALBERT_API_KEY"),
+            "notes": "OpenAI-compatible (selon endpoints activés). Pas de web_search OpenAI.",
+        },
+    }
+
+
+def is_openai_provider(name: str, base_url: str) -> bool:
+    return name.lower().startswith("openai") or "api.openai.com" in base_url
+
+
+def extract_model_ids(models_payload: Any) -> List[str]:
+    """
+    Normalise la sortie /models (ou SDK models.list) en liste d'IDs.
+    """
+    if models_payload is None:
+        return []
+    if isinstance(models_payload, dict) and isinstance(models_payload.get("data"), list):
+        ids = []
+        for m in models_payload["data"]:
+            if isinstance(m, dict) and "id" in m:
+                ids.append(m["id"])
+        return sorted(list(dict.fromkeys(ids)))
+    # parfois payload déjà sous forme list
+    if isinstance(models_payload, list):
+        ids = []
+        for m in models_payload:
+            if isinstance(m, dict) and "id" in m:
+                ids.append(m["id"])
+        return sorted(list(dict.fromkeys(ids)))
+    return []
+
+
+def pick_default(ids: List[str], preferred: List[str]) -> int:
+    """
+    Renvoie l'index d'un modèle préféré s'il existe, sinon 0.
+    """
+    lower = {m.lower(): i for i, m in enumerate(ids)}
+    for p in preferred:
+        if p.lower() in lower:
+            return lower[p.lower()]
+    return 0
+
+
+# ----------------------------
+# Streamlit UI
+# ----------------------------
+st.set_page_config(page_title="LLM API Playground (pédagogique)", layout="wide")
+st.title("Mini-app de requêtes API sur LLMs")
+st.caption("Choisir un provider")
+
+with st.sidebar:
+    st.header("Configuration")
+    defaults = provider_defaults()
+    provider_name = st.selectbox("Fournisseur", list(defaults.keys()), index=0)
+
+    base_url = st.text_input("Base URL", value=defaults[provider_name]["base_url"])
+    env_key = defaults[provider_name]["env_key"]
+
+    st.write(f"Variable d’environnement attendue : `{env_key}`")
+    api_key = st.text_input(
+        "API key (optionnel si déjà dans l'env)",
+        value="",
+        type="password",
+        help=f"Laisse vide si tu as déjà exporté {env_key} dans ton environnement.",
+    )
+    if not api_key:
+        api_key = safe_get_env(env_key, "")
+
+    st.markdown("---")
+    st.info(defaults[provider_name]["notes"])
+
+    st.markdown("---")
+    show_raw = st.toggle("Afficher requête/réponse brutes", value=True)
+    timeout_s = st.slider("Timeout HTTP (s)", 10, 120, 45, 5)
+
+if not api_key and provider_name != "Ollama":
+    st.warning(f"Pas de clé détectée. Renseigne l’API key dans la sidebar ou exporte `{env_key}`.")
+
+client = make_client(base_url=base_url, api_key=api_key if api_key else "NO_KEY")
+
+
+# ----------------------------
+# Load models once per provider/base_url/api_key (cache)
+# ----------------------------
+@st.cache_data(show_spinner=False, ttl=300)
+def load_models_cached(base_url: str, api_key: str, timeout_s: int) -> Tuple[List[str], Optional[Dict[str, Any]], Optional[str]]:
+    """
+    Retourne (ids, raw_payload, error_msg).
+    On tente d'abord via HTTP GET /models (le plus universel).
+    """
+    try:
+        models_url = f"{base_url}/models"
+        raw = http_get_json(models_url, headers=get_headers(api_key), timeout=timeout_s)
+        ids = extract_model_ids(raw)
+        if not ids:
+            return [], raw, "Réponse /models reçue, mais aucun `id` exploitable n'a été trouvé."
+        return ids, raw, None
+    except Exception as e:
+        return [], None, str(e)
+
+
+with st.spinner("Chargement des modèles du provider…"):
+    model_ids, models_raw, models_err = load_models_cached(base_url, api_key, timeout_s)
+
+if models_err:
+    st.sidebar.warning(f"Impossible de charger /models : {models_err}")
+elif model_ids:
+    st.sidebar.success(f"Modèles chargés : {len(model_ids)}")
+else:
+    st.sidebar.warning("Aucun modèle détecté (structure inattendue).")
+
+if show_raw and models_raw:
+    with st.expander("Debug: réponse brute /models"):
+        st.code(pretty(models_raw), language="json")
+
+
+def model_selector(
+    label: str,
+    ids: List[str],
+    preferred: List[str],
+    key: str,
+    fallback_value: str,
+) -> str:
+    """
+    Retourne un model_id :
+    - si ids dispo: selectbox
+    - sinon: text_input fallback
+    """
+    if ids:
+        idx = pick_default(ids, preferred)
+        return st.selectbox(label, ids, index=idx, key=key)
+    return st.text_input(label, value=fallback_value, key=key + "_fallback")
+
+
+tabs = st.tabs(
+    [
+        "1) Lister les modèles",
+        "2) Embeddings",
+        "3) Chat completion",
+        "4) Extraction JSON",
+        "5) OpenAI web_search",
+        "6) OpenAI image → description",
+    ]
+)
+
+# ----------------------------
+# 1) Models
+# ----------------------------
+with tabs[0]:
+    st.subheader("1) Lister les modèles disponibles (`GET /models`)")
+    colA, colB = st.columns([1, 1], vertical_alignment="top")
+
+    with colA:
+        if st.button("🔄 Recharger /models", type="primary"):
+            load_models_cached.clear()
+            st.rerun()
+
+        st.write("IDs détectés :")
+        if model_ids:
+            st.dataframe({"model_id": model_ids})
+        else:
+            st.info("Pas de liste exploitable. (Voir la réponse brute dans la sidebar si activée.)")
+
+    with colB:
+        st.write("À retenir")
+        st.markdown(
+            "- Le dropdown des autres onglets dépend de cette liste.\n"
+            "- Si `/models` est bloqué par un provider, l’app retombe sur un champ texte."
+        )
+
+# ----------------------------
+# 2) Embeddings
+# ----------------------------
+with tabs[1]:
+    st.subheader("2) Embeddings (`POST /embeddings`)")
+    colA, colB = st.columns([1, 1], vertical_alignment="top")
+
+    with colA:
+        emb_model = model_selector(
+            "Modèle d'embeddings",
+            model_ids,
+            preferred=["text-embedding-3-small", "text-embedding-ada-002"],
+            key="emb_model",
+            fallback_value="text-embedding-3-small",
+        )
+        text = st.text_area("Texte à embedder", value="This is a test", height=120)
+
+        if st.button("🧬 Calculer embeddings", type="primary"):
+            try:
+                emb_url = f"{base_url}/embeddings"
+                payload = {"model": emb_model, "input": text}
+                t0 = time.time()
+                resp = http_post_json(emb_url, headers=get_headers(api_key), payload=payload, timeout=timeout_s)
+                dt = time.time() - t0
+
+                st.success(f"OK — {dt:.2f}s")
+                try:
+                    emb = resp["data"][0]["embedding"]
+                    st.write(f"Dimension : **{len(emb)}**")
+                except Exception:
+                    st.info("Impossible d'extraire `data[0].embedding` (structure différente).")
+
+                usage = resp.get("usage", {})
+                if usage:
+                    st.write(f"Usage : `{pretty(usage)}`")
+
+                if show_raw:
+                    st.code(pretty(resp), language="json")
+            except Exception as e:
+                st.error(f"Erreur: {e}")
+
+    #with colB:
+        #st.write("À retenir")
+        #st.markdown("- Le modèle sélectionné vient de `/models` quand c’est possible.\n- Sinon, saisis l’ID à la main.")
+
+# ----------------------------
+# 3) Chat completion
+# ----------------------------
+with tabs[2]:
+    st.subheader("3) Chat completion (`POST /chat/completions`)")
+    colA, colB = st.columns([1, 1], vertical_alignment="top")
+
+    with colA:
+        chat_model = model_selector(
+            "Modèle (chat)",
+            model_ids,
+            preferred=["gpt-4o-mini", "gpt-4.1-mini", "gpt-4", "llama", "mixtral"],
+            key="chat_model",
+            fallback_value="gpt-4o-mini",
+        )
+        prompt = st.text_area(
+            "Prompt utilisateur",
+            value="Explique la différence entre modèles de langage encodeur et modèle de langage décodeur.",
+            height=140,
+        )
+        max_tokens = st.slider("max_completion_tokens", 32, 512, 200, 16)
+        temperature = st.slider("temperature", 0.0, 1.5, 0.3, 0.1)
+
+        if st.button("💬 Générer", type="primary"):
+            try:
+                completion_url = f"{base_url}/chat/completions"
+                payload = {
+                    "model": chat_model,
+                    "messages": [{"role": "user", "content": prompt}],
+                    "max_completion_tokens": max_tokens,
+                    "temperature": temperature,
+                    "stream": False,
+                }
+                t0 = time.time()
+                resp = http_post_json(completion_url, headers=get_headers(api_key), payload=payload, timeout=timeout_s)
+                dt = time.time() - t0
+
+                st.success(f"OK — {dt:.2f}s")
+                try:
+                    content = resp["choices"][0]["message"]["content"]
+                    st.markdown("### Réponse")
+                    st.write(content)
+                except Exception:
+                    st.info("Structure de réponse inattendue. Regarde la réponse brute.")
+                if show_raw:
+                    st.code(pretty(resp), language="json")
+            except Exception as e:
+                st.error(f"Erreur: {e}")
+
+    #with colB:
+    #    st.write("À retenir")
+    #    st.markdown("- Même endpoint, providers différents.\n- Le dropdown aide à éviter les IDs de modèles invalides.")
+
+# ----------------------------
+# 4) JSON extraction
+# ----------------------------
+with tabs[3]:
+    st.subheader("4) Extraction structurée en JSON (`response_format`)")
+    colA, colB = st.columns([1, 1], vertical_alignment="top")
+
+    with colA:
+        json_model = model_selector(
+            "Modèle (extraction)",
+            model_ids,
+            preferred=["gpt-4o-mini", "gpt-4.1-mini"],
+            key="json_model",
+            fallback_value="gpt-4o-mini",
+        )
+        system = st.text_input("System prompt", value="You are a data extractor")
+        text = st.text_area(
+            "Texte à analyser",
+            value="Le 12 janvier 2023, Marie Curie a rencontré Albert Einstein à Paris.",
+            height=120,
+        )
+        temp = st.slider("temperature (extraction)", 0.0, 1.0, 0.1, 0.05)
+
+        if st.button("🧾 Extraire en JSON", type="primary"):
+            try:
+                resp = client.chat.completions.create(
+                    model=json_model,
+                    messages=[
+                        {"role": "system", "content": system},
+                        {
+                            "role": "user",
+                            "content": f"Extract the places, persons and dates from the following text and respond in JSON format: {text}",
+                        },
+                    ],
+                    temperature=temp,
+                    response_format={"type": "json_object"},
+                    stream=False,
+                )
+                content = resp.choices[0].message.content
+                st.markdown("### JSON retourné")
+                try:
+                    st.json(json.loads(content))
+                except Exception:
+                    st.code(content, language="json")
+
+                if show_raw:
+                    raw = resp.model_dump() if hasattr(resp, "model_dump") else resp
+                    st.code(pretty(raw), language="json")
+            except Exception as e:
+                st.error(f"Erreur: {e}")
+                st.info("Certains providers/modèles ne supportent pas `response_format`.")
+
+    #with colB:
+    #    st.write("À retenir")
+    #    st.markdown("- Dropdown = modèle valide (quand `/models` répond).\n- `response_format` peut rester non supporté selon provider.")
+
+# ----------------------------
+# 5) OpenAI web_search (Responses API)
+# ----------------------------
+with tabs[4]:
+    st.subheader("5) OpenAI — Tool `web_search` via Responses API")
+    if not is_openai_provider(provider_name, base_url):
+        st.warning("Cet onglet est conçu pour OpenAI (Responses API + tool web_search).")
+    else:
+        colA, colB = st.columns([1, 1], vertical_alignment="top")
+        with colA:
+            resp_model = model_selector(
+                "Modèle (Responses)",
+                model_ids,
+                preferred=["gpt-5", "gpt-4.1", "gpt-4.1-mini"],
+                key="resp_model",
+                fallback_value="gpt-5",
+            )
+            reasoning = st.selectbox("reasoning.effort", ["minimal", "low", "medium", "high"], index=3)
+            verbosity = st.selectbox("text.verbosity", ["low", "medium", "high"], index=1)
+            prompt = st.text_area(
+                "Prompt",
+                value=(
+                    "Voici quels métadonnées bibliographiques :\n"
+                    "- titre : L'enfant et la rivière\n"
+                    "- auteur : Henri Bosco\n"
+                    "- date : 2015\n\n"
+                    "Fais une recherche dans le catalogue CCFr et trouve le nombre de localisations Sudoc."
+                ),
+                height=180,
+            )
+            if st.button("Lancer web_search", type="primary"):
+                try:
+                    resp = client.responses.create(
+                        model=resp_model,
+                        input=prompt,
+                        tools=[{"type": "web_search"}],
+                        reasoning={"effort": reasoning},
+                        text={"verbosity": verbosity},
+                        stream=False,
+                    )
+                    st.markdown("### Réponse")
+                    st.write(resp.output_text if getattr(resp, "output_text", None) else "(pas de output_text)")
+                    if show_raw:
+                        raw = resp.model_dump() if hasattr(resp, "model_dump") else resp
+                        st.code(pretty(raw), language="json")
+                except Exception as e:
+                    st.error(f"Erreur: {e}")
+
+        with colB:
+            st.write("À retenir")
+            st.markdown("- Ici le modèle **appelle un outil**.\n- Ce tab reste OpenAI-only dans cette démo.")
+
+# ----------------------------
+# 6) OpenAI image description
+# ----------------------------
+with tabs[5]:
+    st.subheader("6) OpenAI — Décrire une image (Responses API, multimodal)")
+    if not is_openai_provider(provider_name, base_url):
+        st.warning("Cet onglet est conçu pour OpenAI (Responses API + input_image).")
+    else:
+        colA, colB = st.columns([1, 1], vertical_alignment="top")
+        with colA:
+            img_model = model_selector(
+                "Modèle (multimodal)",
+                model_ids,
+                preferred=["gpt-4.1-mini", "gpt-4o-mini"],
+                key="img_model",
+                fallback_value="gpt-4.1-mini",
+            )
+            image_url = st.text_input(
+                "Image URL",
+                value="https://github.com/gegedenice/divers-files/raw/ca7c12ae2955a804b8a050c0f9ce77e2c0ef3aad/aude_edouard.jpg",
+            )
+            instruction = st.text_area("Instruction", value="Décris précisément cette image. Réponds en français.", height=120)
+
+            st.image(image_url, caption="Aperçu (si accessible)", use_container_width=True)
+
+            if st.button("Décrire", type="primary"):
+                try:
+                    resp = client.responses.create(
+                        model=img_model,
+                        input=[
+                            {
+                                "role": "user",
+                                "content": [
+                                    {"type": "input_text", "text": instruction},
+                                    {"type": "input_image", "image_url": image_url},
+                                ],
+                            }
+                        ],
+                    )
+                    st.markdown("### Description")
+                    st.write(resp.output_text)
+                    if show_raw:
+                        raw = resp.model_dump() if hasattr(resp, "model_dump") else resp
+                        st.code(pretty(raw), language="json")
+                except Exception as e:
+                    st.error(f"Erreur: {e}")
+
+        #with colB:
+        #    st.write("À retenir")
+        #    st.markdown("- Multimodal OpenAI.\n- Dropdown = modèle valide quand la liste est accessible.")
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+st.markdown("---")
+st.caption("Astuce : si `/models` ne marche pas chez un provider, la fallback text_input permet quand même de tester.")