gradio chat app fonctionne - streaming

.gitattributes

@@ -0,0 +1 @@
+assets/chatbot.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,10 @@
+.env
+.venv
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.pyw
+*.pyz
+*.pywz
+*.pyzw

app.py

@@ -1,216 +1,147 @@
-import os, ast, threading
-from typing import List, Dict, Any, Optional, Tuple
+import os, time
+from dotenv import load_dotenv
+
+# Load environment variables BEFORE importing rag modules
+load_dotenv(override=True)
 
 import gradio as gr
-import numpy as np
-from datasets import load_dataset
-from huggingface_hub import InferenceClient
-
-# -------------------------------
-# Config
-# -------------------------------
-EMBED_COL = os.getenv("EMBED_COL", "embeddings_bge-m3")
-DATASETS = [
-    ("edouardfoussier/travail-emploi-clean", "train"),
-    ("edouardfoussier/service-public-filtered", "train"),
-]
-
-HF_API_TOKEN   = os.getenv("HF_API_TOKEN")
-HF_EMBED_MODEL = os.getenv("HF_EMBED_MODEL", "BAAI/bge-m3")
-HF_LLM_MODEL   = os.getenv("HF_LLM_MODEL", "mistralai/Mistral-7B-Instruct-v0.2")
-
-if not HF_API_TOKEN:
-    raise RuntimeError("HF_API_TOKEN not set. Add it in Space → Settings → Variables.")
-
-# Try FAISS; fallback to NumPy if not available
-_USE_FAISS = True
-try:
-    import faiss  # type: ignore
-except Exception:
-    _USE_FAISS = False
-
-# -------------------------------
-# Globals
-# -------------------------------
-_embed_client: Optional[InferenceClient] = None
-_gen_client:   Optional[InferenceClient] = None
-
-_index = None        # FAISS index or dense matrix (NumPy)
-_payloads = None     # list[dict]
-_dim = None
-_lock = threading.Lock()
-
-def _get_embed_client() -> InferenceClient:
-    global _embed_client
-    if _embed_client is None:
-        _embed_client = InferenceClient(token=HF_API_TOKEN)
-    return _embed_client
-
-def _get_gen_client() -> InferenceClient:
-    global _gen_client
-    if _gen_client is None:
-        _gen_client = InferenceClient(token=HF_API_TOKEN)
-    return _gen_client
-
-def _to_vec(x):
-    if isinstance(x, list):
-        return np.asarray(x, dtype=np.float32)
-    if isinstance(x, str):
-        return np.asarray(ast.literal_eval(x), dtype=np.float32)
-    raise TypeError(f"Unsupported embedding type: {type(x)}")
-
-def _normalize(v: np.ndarray) -> np.ndarray:
-    v = v.astype(np.float32, copy=False)
-    n = np.linalg.norm(v) + 1e-12
-    return v / n
-
-def _embed_query(text: str) -> np.ndarray:
-    # HF feature-extraction
-    vec = _get_embed_client().feature_extraction(text, model=HF_EMBED_MODEL)
-    v = np.asarray(vec, dtype=np.float32)
-    if v.ndim == 2:
-        v = v[0]
-    return _normalize(v)
-
-def _load_datasets() -> Tuple[np.ndarray, List[Dict[str, Any]]]:
-    vecs, payloads = [], []
-    for name, split in DATASETS:
-        ds = load_dataset(name, split=split)
-        for row in ds:
-            v = _normalize(_to_vec(row[EMBED_COL]))
-            vecs.append(v)
-            p = dict(row); p.pop(EMBED_COL, None)
-            payloads.append(p)
-    X = np.stack(vecs, axis=0)
-    return X, payloads
-
-def _build_index() -> Tuple[Any, List[Dict[str, Any]], int]:
-    X, payloads = _load_datasets()
-    dim = X.shape[1]
-    if _USE_FAISS:
-        idx = faiss.IndexFlatIP(dim)
-        idx.add(X)
-    else:
-        idx = X  # NumPy matrix
-    return idx, payloads, dim
-
-def _ensure_index():
-    global _index, _payloads, _dim
-    if _index is not None:
+from rag.retrieval import search, embed
+from rag.synth import synth_answer_stream, render_sources
+from helpers import linkify_text_with_sources
+
+missing = []
+if not os.getenv("HF_API_TOKEN"): missing.append("HF_API_TOKEN (embeddings)")
+if not os.getenv("LLM_MODEL"):    print("[INFO] LLM_MODEL not set, using default", flush=True)
+print("[ENV] Missing:", ", ".join(missing) or "None", flush=True)
+# HF_API_TOKEN = os.getenv("HF_API_TOKEN")
+
+# def sanity():
+#     ok = bool(os.getenv("HF_API_TOKEN"))
+#     v = embed("hello world")
+#     return f"Token set? {ok}\nEmbedding dim: {len(v)}"
+
+# def rag_chat(user_question, openai_key):
+#     if not openai_key:
+#         return "❌ Please provide your OpenAI API key."
+
+#     # Inject the key into environment so synth can use it
+#     os.environ["OPENAI_API_KEY"] = openai_key
+
+#     # Step 1: Retrieve top passages
+#     hits = search(user_question, top_k=8)
+
+#     if not hits:
+#         return "❌ Sorry, no relevant information found."
+
+    # # Step 2: Generate synthesized answer
+    # try:
+    #     final_answer = synth_answer(user_question, hits[:5])
+    #     final_answer = linkify(final_answer, hits[:5])
+    #     final_answer += "\n\n---\n" + render_sources(hits[:5])
+    # except Exception as e:
+    #     final_answer = f"❌ Error during synthesis: {e}"
+
+    # return final_answer
+# def rag_chat(user_question, openai_key):
+#     if not openai_key:
+#         yield "❌ Please provide your OpenAI API key."
+#         return
+
+#     os.environ["OPENAI_API_KEY"] = openai_key
+
+#     hits = search(user_question, top_k=8)
+#     if not hits:
+#         yield "❌ Sorry, no relevant information found."
+#         return
+
+#     acc = ""
+#     try:
+#         for piece in synth_answer_stream(user_question, hits[:5]):
+#             acc += piece or ""
+#             # stream raw text while typing (no links yet to avoid jumpiness)
+#             yield acc
+#     except Exception as e:
+#         partial = acc if acc.strip() else ""
+#         yield (partial + ("\n\n" if partial else "") + f"❌ Streaming error: {e}")
+#         return
+
+#     final_md = linkify_text_with_sources(acc, hits[:5])
+#     yield final_md
+
+
+
+# with gr.Blocks() as demo:
+#     gr.Markdown("## 🤖 HR Assistant (RAG)\nAsk your question below:")
+
+#     with gr.Row():
+#         api_key = gr.Textbox(label="🔑 Your OpenAI API Key", type="password")
+    
+#     question = gr.Textbox(label="❓ Your Question", placeholder="e.g., Quels sont les droits à congés ?")
+    
+#     answer = gr.Markdown(label="💡 Assistant Answer")
+
+#     submit_btn = gr.Button("Ask")
+
+#     submit_btn.click(fn=rag_chat, inputs=[question, api_key], outputs=answer)
+
+
+# if __name__ == "__main__":
+#     demo.launch()
+
+
+def rag_chat(user_question: str, openai_key: str):
+    """Generator: streams draft text to a Textbox, then yields final Markdown."""
+    if not openai_key:
+        yield "❌ Please provide your OpenAI API key.", None
         return
-    with _lock:
-        if _index is None:
-            _index, _payloads, _dim = _build_index()
-
-def _search_numpy(X: np.ndarray, q: np.ndarray, k: int):
-    scores = X @ q  # cosine/IP (normalized)
-    k = min(k, len(scores))
-    part = np.argpartition(-scores, k-1)[:k]
-    order = part[np.argsort(-scores[part])]
-    return scores[order], order
-
-def retrieve(query: str, top_k: int = 6) -> List[Dict[str, Any]]:
-    _ensure_index()
-    q = _embed_query(query)
-    if _USE_FAISS:
-        D, I = _index.search(q[None, :], top_k)
-        scores, idxs = D[0], I[0]
-    else:
-        scores, idxs = _search_numpy(_index, q, top_k)
-    out = []
-    for idx, sc in zip(idxs, scores):
-        if idx == -1:
-            continue
-        p = _payloads[int(idx)]
-        out.append({"score": float(sc), "payload": p})
-    return out
-
-def build_prompt(query: str, passages: List[Dict[str, Any]]) -> str:
-    chunks = []
-    for i, h in enumerate(passages, 1):
-        p = h["payload"]
-        text = p.get("text") or p.get("chunk_text") or ""
-        source = p.get("source") or "unknown"
-        title = p.get("title") or ""
-        url = p.get("url") or ""
-        chunks.append(f"[{i}] ({source}) {title}\n{text}\nURL: {url}\n")
-    context = "\n\n".join(chunks)
-    return f"""You are a helpful HR assistant. Answer the question strictly using the CONTEXT.
-If the CONTEXT is not enough, say you don't know.
-
-QUESTION:
-{query}
-
-CONTEXT:
-{context}
-
-Answer in French. Cite sources inline like [1], [2] where relevant.
-"""
-
-def stream_llm(prompt: str):
-    # Stream tokens from HF Inference API text generation
-    client = _get_gen_client()
-    # temperature/params small so result is stable
-    stream = client.text_generation(
-        model=HF_LLM_MODEL,
-        prompt=prompt,
-        max_new_tokens=512,
-        temperature=0.2,
-        top_p=0.9,
-        stream=True,
-        stop=None,
-    )
-    for chunk in stream:
-        # chunk is a string token or piece; just yield it
-        yield chunk
-
-def format_sources(passages: List[Dict[str, Any]]) -> str:
-    lines = []
-    for i, h in enumerate(passages, 1):
-        p = h["payload"]
-        title = (p.get("title") or "").strip() or "(Sans titre)"
-        url = p.get("url") or ""
-        src = p.get("source") or "unknown"
-        lines.append(f"[{i}] **{title}** — _{src}_  " + (f"[lien]({url})" if url else ""))
-    return "\n".join(lines)
-
-# -------------------------------
-# Gradio Chat handler
-# -------------------------------
-def respond(message, history):
-    # Retrieve
-    passages = retrieve(message, top_k=6)
-    prompt = build_prompt(message, passages)
-
-    # Stream answer
-    answer_so_far = ""
-    for token in stream_llm(prompt):
-        answer_so_far += token
-        yield answer_so_far
-
-    # Append sources as an expandable block (return another message)
-    sources_md = format_sources(passages)
-    yield answer_so_far + "\n\n---\n**Sources**\n" + sources_md
-
-with gr.Blocks(fill_height=True) as demo:
-    gr.Markdown("## 🔎 Assistant RH — RAG Chatbot")
-    gr.Markdown(
-        f"**Embeddings:** `{HF_EMBED_MODEL}`   |   **LLM:** `{HF_LLM_MODEL}`"
-    )
-    chat = gr.ChatInterface(
-        fn=respond,
-        type="messages",
-        title="Assistant RH",
-        examples=[
-            "Quels sont les droits à congés pour un agent contractuel ?",
-            "Comment déclarer l’embauche d’un salarié (DPAE) ?",
-            "Quelles sont les obligations de l’employeur pour le télétravail ?",
-        ],
-        retry_btn="Reformuler",
-        undo_btn=None,
-        clear_btn="Effacer",
-        description="Posez une question RH. Réponse générée avec récupération documentaire.",
+
+    os.environ["OPENAI_API_KEY"] = openai_key.strip()
+
+    # Step 1: retrieve
+    yield "⏳ Recherche des passages pertinents…", None
+    hits = search(user_question, top_k=8)
+    if not hits:
+        yield "❌ Sorry, no relevant information found.", None
+        return
+
+    # Step 2: stream LLM synthesis
+    acc = ""
+    try:
+        for piece in synth_answer_stream(user_question, hits[:5]):
+            acc += piece or ""
+            # Stream into the draft textbox; keep markdown empty during typing
+            yield acc, None
+    except Exception as e:
+        yield f"❌ Error during synthesis: {e}", None
+        return
+
+    # Step 3: finalize + linkify citations in Markdown block
+    md = linkify_text_with_sources(acc, hits[:5])
+    yield acc, md
+
+with gr.Blocks() as demo:
+    gr.Markdown("## 🤖 HR Assistant (RAG)\nAsk your question below:")
+
+    with gr.Row():
+        api_key = gr.Textbox(label="🔑 Your OpenAI API Key", type="password", placeholder="sk-…")
+    question = gr.Textbox(label="❓ Your Question", placeholder="e.g., Quels sont les droits à congés ?")
+
+    # live streaming target
+    draft_answer = gr.Markdown(label="💬 Réponse")
+    # final pretty markdown with clickable links
+    # final_answer = gr.Markdown()
+
+    with gr.Row():
+        submit_btn = gr.Button("Ask", variant="primary")
+        clear_btn = gr.Button("Clear")
+
+    submit_btn.click(
+        fn=rag_chat,
+        inputs=[question, api_key],
+        outputs=[draft_answer, final_answer],
+        show_progress="full",  # shows loader on the button
     )
+    clear_btn.click(lambda: ("", ""), outputs=[draft_answer, final_answer])
 
 if __name__ == "__main__":
-    demo.queue(concurrency_count=2).launch(server_name="0.0.0.0", server_port=7860)
+    demo.queue().launch()

helpers.py

@@ -0,0 +1,25 @@
+import re
+
+def linkify_text_with_sources(text: str, passages: list[dict]) -> str:
+    """
+    Convert [1], [2]… in `text` to markdown links using the corresponding
+    passage payloads (expects top-5 `hits` from your retriever).
+    """
+    # Build mapping: 1-based index -> (title, url)
+    mapping = {}
+    for i, h in enumerate(passages, start=1):
+        p = h.get("payload", h) or {}
+        title = p.get("title") or p.get("url") or f"Source {i}"
+        url = p.get("url")
+        mapping[i] = (title, url)
+
+    def _sub(m):
+        idx = int(m.group(1))
+        title, url = mapping.get(idx, (None, None))
+        if url:
+            # turn [n] into [n](url "title")
+            return f"[{idx}]({url} \"{title}\")"
+        # leave as plain [n] if no URL
+        return m.group(0)
+
+    return re.sub(r"\[(\d+)\]", _sub, text)

rag/retrieval.py

@@ -0,0 +1,115 @@
+import os, threading, ast
+from typing import List, Dict, Any, Optional, Tuple
+
+import numpy as np
+from datasets import load_dataset
+from huggingface_hub import InferenceClient
+
+EMBED_COL = os.getenv("EMBED_COL", "embeddings_bge-m3")
+DATASETS = [
+    ("edouardfoussier/travail-emploi-clean", "train"),
+    ("edouardfoussier/service-public-filtered", "train"),
+]
+HF_EMBED_MODEL = os.getenv("HF_EMBEDDINGS_MODEL", "BAAI/bge-m3")
+HF_API_TOKEN  = os.getenv("HF_API_TOKEN")
+
+# Try FAISS; fallback to NumPy if import fails
+_USE_FAISS = True
+try:
+    import faiss  # type: ignore
+except Exception:
+    _USE_FAISS = False
+
+_embed_client: Optional[InferenceClient] = None
+_index = None           # faiss index or np.ndarray
+_payloads = None        # list[dict]
+_lock = threading.Lock()
+
+def _client() -> InferenceClient:
+    global _embed_client
+    if _embed_client is None:
+        if not HF_API_TOKEN:
+            raise RuntimeError("HF_API_TOKEN missing (.env)")
+        _embed_client = InferenceClient(model=HF_EMBED_MODEL, token=HF_API_TOKEN)
+    return _embed_client
+
+def _to_vec(x):
+    if isinstance(x, list): return np.asarray(x, dtype=np.float32)
+    if isinstance(x, str):  return np.asarray(ast.literal_eval(x), dtype=np.float32)
+    raise TypeError(f"Bad embedding type: {type(x)}")
+
+def _norm(v: np.ndarray) -> np.ndarray:
+    v = v.astype(np.float32, copy=False)
+    n = np.linalg.norm(v) + 1e-12
+    return v / n
+
+def embed(text: str) -> np.ndarray:
+    vec = _client().feature_extraction(text)
+    v = np.asarray(vec, dtype=np.float32)
+    if v.ndim == 2: v = v[0]
+    return _norm(v)
+
+def _load_corpus() -> Tuple[np.ndarray, List[Dict[str, Any]]]:
+    vecs, payloads = [], []
+    for name, split in DATASETS:
+        ds = load_dataset(name, split=split)
+        for row in ds:
+            v = _norm(_to_vec(row[EMBED_COL]))
+            vecs.append(v)
+            p = dict(row); p.pop(EMBED_COL, None)
+            payloads.append(p)
+    X = np.stack(vecs, axis=0)
+    return X, payloads
+
+def _build_index():
+    X, payloads = _load_corpus()
+    if _USE_FAISS:
+        dim = X.shape[1]
+        idx = faiss.IndexFlatIP(dim)
+        idx.add(X)
+        return idx, payloads
+    else:
+        return X, payloads  # NumPy fallback
+
+def _ensure():
+    global _index, _payloads
+    if _index is not None: return
+    with _lock:
+        if _index is None:
+            _index, _payloads = _build_index()
+
+def _search_numpy(X: np.ndarray, q: np.ndarray, k: int):
+    scores = X @ q
+    k = min(k, len(scores))
+    part = np.argpartition(-scores, k-1)[:k]
+    order = part[np.argsort(-scores[part])]
+    return scores[order], order
+
+def rerank_cosine(query_vec, hits, top_k=5):
+    # Re-embed candidate texts and compare? (expensive)
+    # or use retrieval scores only (already cosine). If using NumPy fallback,
+    # you can keep as is. For a tiny boost, score by length-normalized match:
+    scored = []
+    for h in hits:
+        txt = (h["payload"].get("text") or "")
+        # penalize super-long chunks a bit
+        penalty = 1.0 / (1.0 + len(txt)/1500.0)
+        scored.append((h["score"] * penalty, h))
+    scored.sort(key=lambda x: x[0], reverse=True)
+    return [h for _, h in scored[:top_k]]
+
+def search(query: str, top_k: int = 5) -> List[Dict[str, Any]]:
+    _ensure()
+    q = embed(query)
+    if _USE_FAISS:
+        D, I = _index.search(q[None, :], top_k)
+        scores, idxs = D[0], I[0]
+    else:
+        scores, idxs = _search_numpy(_index, q, top_k)
+    hits = []
+    for i, s in zip(idxs, scores):
+        if i == -1: continue
+        p = _payloads[int(i)]
+        hits.append({"score": float(s), "payload": p})
+    return hits
+

rag/synth.py

@@ -0,0 +1,157 @@
+import os
+from openai import OpenAI
+
+LLM_MODEL = os.getenv("LLM_MODEL", "gpt-4o-mini")
+LLM_BASE_URL = os.getenv("LLM_BASE_URL", "https://api.openai.com/v1")
+
+def _build_prompt(query, passages):
+    ctx = "\n\n".join([(p["payload"].get("text") or "") for p in passages])
+    return (
+        "Tu es un assistant RH de la fonction publique française.\n"
+        "- Réponds de façon factuelle et concise.\n"
+        "- Cite les sources en fin de phrase avec [1], [2]… basées sur l’ordre des passages.\n"
+        "- Si l’info n’est pas dans les sources, réponds « Je ne sais pas ».\n\n"
+        f"Question: {query}\n\nSources (indexées):\n{ctx}\n\nRéponse:"
+    )
+
+def synth_answer_stream(query, passages):
+    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"), base_url=LLM_BASE_URL)
+    prompt = _build_prompt(query, passages)
+    stream = client.chat.completions.create(
+        model=LLM_MODEL,
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0.2,
+        stream=True,  # 👈 IMPORTANT
+    )
+    # The SDK yields events with deltas
+    for event in stream:
+        delta = getattr(getattr(event, "choices", [None])[0], "delta", None)
+        if delta and delta.content:
+            yield delta.content
+
+# def linkify(text, passages):
+#     # (optional) keep simple: return text as-is for now
+#     return text
+
+def render_sources(passages):
+    lines = []
+    for i, p in enumerate(passages, 1):
+        title = (p["payload"].get("title") or "").strip() or "Sans titre"
+        url = p["payload"].get("url") or ""
+        lines.append(f"[{i}] {title}{' – ' + url if url else ''}")
+    return "\n".join(lines)
+
+# def linkify_text_with_sources(text: str, passages):
+#     """
+#     Replace [1], [2]... with clickable links if the passage has a URL.
+#     Also append a Sources section as a numbered list.
+#     """
+#     # Build a map: 1-based index -> url
+#     urls = []
+#     for p in passages:
+#         url = (p["payload"].get("url") or "").strip()
+#         urls.append(url if url.startswith("http") else "")
+
+#     # Inline [n] -> [n](url) when available
+#     out = text
+#     for i, url in enumerate(urls, start=1):
+#         if url:
+#             out = out.replace(f"[{i}]", f"[{i}]({url})")
+
+#     # Add a Sources section
+#     lines = ["\n\n---\n**Sources**"]
+#     for i, p in enumerate(passages, start=1):
+#         title = (p["payload"].get("title") or "").strip() or "Sans titre"
+#         url = (p["payload"].get("url") or "").strip()
+#         if url.startswith("http"):
+#             lines.append(f"{i}. [{title}]({url})")
+#         else:
+#             lines.append(f"{i}. {title}")
+#     return out + "\n" + "\n".join(lines)
+# import os
+# from openai import OpenAI
+
+# LLM_MODEL = os.getenv("LLM_MODEL", "gpt-4o-mini")
+# LLM_BASE_URL = os.getenv("LLM_BASE_URL", "https://api.openai.com/v1")
+
+# def _first_k_chars(text, k=1200):
+#     t = text.strip()
+#     return t[:k] + ("…" if len(t) > k else "")
+
+# def _build_prompt(query, passages):
+#     chunks = []
+#     for i, p in enumerate(passages, 1):
+#         txt = p["payload"].get("text") or ""
+#         chunks.append(f"[{i}] {_first_k_chars(txt)}")
+
+# # def _build_prompt(query, passages):
+# #     chunks = []
+# #     for i, p in enumerate(passages, 1):
+# #         txt = p["payload"].get("text") or ""
+#         # chunks.append(f"[{i}] {txt}")
+#     context = "\n\n".join(chunks)
+
+#     return f"""Tu es un assistant RH de la fonction publique française.
+# - Réponds de manière factuelle et concise.
+# - Cite tes sources en fin de phrase avec [n] correspondant aux extraits ci-dessous.
+# - Si l’information n’est pas dans les sources, réponds : “Je ne sais pas”.
+# - Ne fabrique pas de liens ni de références.
+
+# Question: {query}
+
+# Extraits indexés:
+# {context}
+
+# Réponse:"""
+
+# def synth_answer_stream(query, passages):
+#     client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"), base_url=LLM_BASE_URL)
+#     prompt = _build_prompt(query, passages)
+
+#     # ✅ Correct streaming usage
+#     stream = client.chat.completions.create(
+#         model=LLM_MODEL,
+#         messages=[{"role": "user", "content": prompt}],
+#         temperature=0.2,
+#         stream=True,  # <- this is key
+#     )
+#     for chunk in stream:
+#         delta = getattr(chunk.choices[0].delta, "content", None)
+#         if delta:
+#             acc.append(delta)
+#             yield delta  # stream piece by piece
+# # def synth_answer(query, passages):
+# #     client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"), base_url=LLM_BASE_URL)
+# #     prompt = _build_prompt(query, passages)
+
+# #     resp = client.chat.completions.create(
+# #         model=LLM_MODEL,
+# #         messages=[{"role": "user", "content": prompt}],
+# #         temperature=0.2,
+# #     )
+# #     return resp.choices[0].message.content.strip()
+
+# # --- HELPERS
+
+# def render_sources(passages):
+#     lines = []
+#     for i, p in enumerate(passages, 1):
+#         pl = p["payload"]
+#         title = (pl.get("title") or "Source").strip()
+#         url = pl.get("url") or ""
+#         lines.append(f"[{i}] {title}" + (f" — {url}" if url else ""))
+#     return "\n".join(lines)
+
+# def linkify(text, passages):
+#     # turn [1] -> markdown link when url exists
+#     for i, p in enumerate(passages, 1):
+#         url = p["payload"].get("url")
+#         if url:
+#             text = text.replace(f"[{i}]", f"[{i}]({url})")
+#     return text
+
+
+
+
+
+

requirements.txt

@@ -3,4 +3,5 @@ datasets>=2.19.0
 huggingface-hub>=0.20
 faiss-cpu==1.7.4
 numpy<2
-python-dotenv
+python-dotenv
+openai>=1.0.0