Add team yml and endpoint LLM models

README.md

@@ -111,7 +111,7 @@ Persist embeddings in a vector store optimized for similarity search.
 ```python
 import chromadb
 
-client = chromadb.PersistentClient(path="./chroma_db")
+client = chromadb.PersistentClient(path="./data/chroma_db")
 collection = client.get_or_create_collection(
     name="rag_documents",
     metadata={"hnsw:space": "cosine"},
@@ -336,89 +336,101 @@ curl -X POST http://localhost:7860/ingest \
 
 ## Adding Binary Files to the HF Space
 
-Large or binary files (e.g., pre-built ChromaDB databases, PDFs, images, model weights) cannot be pushed with regular `git push` because Hugging Face repositories enforce a **10 MB file-size limit** for standard Git. Use one of the methods below to make them available to your Space at runtime.
+Large or binary files (PDFs, pre-built ChromaDB databases, datasets, model weights) are stored in a **Hugging Face bucket** and mounted into the Space container at `/data`. The `hf sync` command keeps your local folder in sync with the bucket.
 
-### Method 1: Git LFS (recommended for files < 5 GB)
+> **Note:** Git LFS is not supported for Hugging Face Spaces persistent storage. Use the bucket + `hf sync` workflow described here instead.
 
-Hugging Face repos support [Git Large File Storage (LFS)](https://git-lfs.com/). Files tracked by LFS are stored in a dedicated bucket and downloaded transparently when the Space starts.
+### Prerequisites
 
 ```bash
-# 1. Install Git LFS (once per machine)
-git lfs install
+# Install the hf CLI (requires uv)
+uv tool install "huggingface_hub[cli]"
 
-# 2. Track the binary patterns you need
-git lfs track "*.pdf"
-git lfs track "*.sqlite3"
-git lfs track "chroma_db/**"
-git lfs track "DataSet/**"
+# Authenticate (needs Write access to the bucket)
+export HF_TOKEN="hf_your_token_here"
+# or interactively:
+hf auth login
+```
 
-# This updates .gitattributes — commit it
-git add .gitattributes
-git commit -m "chore: track binary files with Git LFS"
+### Step 1 — Attach the Storage Bucket to Your Space
 
-# 3. Add and push the binary files
-git add chroma_db/ DataSet/
-git commit -m "feat: add pre-built vector store and datasets"
-git push
-```
+1. Open your Space on huggingface.co
+2. Go to **Settings → Persistent Storage**
+3. Under **"Attach storage"**, select the existing bucket **`millimanfrance/Example-App-Hackathon-Gustave-Eiffel-2026-storage`** (or create a new one)
+4. Save — Hugging Face will mount the bucket at `/data` inside the Space container
 
-> **Verify:** After pushing, open your Space repo on huggingface.co and click on an LFS file — it should show `Stored with Git LFS` instead of raw content.
+### Step 2 — Upload Files from Your Local Machine
 
-### Method 2: Upload via the `huggingface_hub` Python SDK
+Place all persistent files under a local `./data` folder. The expected structure is:
 
-Use this when you want to upload files programmatically (e.g., from a CI pipeline or a notebook) without cloning the full repo.
+```
+./data/
+├── chroma_db/          # Pre-built ChromaDB vector store
+│   └── chroma.sqlite3
+├── sample_documents/   # Text/PDF files ingested on startup
+│   ├── eiffel_tower.txt
+│   └── gustave_eiffel.txt
+└── DataSet/            # Training/test datasets (PDFs, CSVs, etc.)
+    ├── Automobile/
+    ├── Climatique/
+    └── ...
+```
 
-```python
-from huggingface_hub import HfApi
+Then push:
 
-api = HfApi()
+```bash
+# Sync the entire ./data folder to the bucket
+hf sync ./data hf://buckets/millimanfrance/Example-App-Hackathon-Gustave-Eiffel-2026-storage
 
-# Upload a single file
-api.upload_file(
-    path_or_fileobj="./chroma_db/chroma.sqlite3",
-    path_in_repo="chroma_db/chroma.sqlite3",
-    repo_id="YOUR_USERNAME/Example-App-Hackathon-Gustave-Eiffel-2026",
-    repo_type="space",
-)
+# Sync only a specific sub-folder (e.g., the vector store)
+hf sync ./data/chroma_db hf://buckets/millimanfrance/Example-App-Hackathon-Gustave-Eiffel-2026-storage/chroma_db
 
-# Upload an entire folder
-api.upload_folder(
-    folder_path="./DataSet",
-    path_in_repo="DataSet",
-    repo_id="YOUR_USERNAME/Example-App-Hackathon-Gustave-Eiffel-2026",
-    repo_type="space",
-)
+# Sync only specific file types
+hf sync ./data hf://buckets/millimanfrance/Example-App-Hackathon-Gustave-Eiffel-2026-storage \
+  --include "*.pdf" --include "*.sqlite3"
 ```
 
-> **Authentication:** Set `HF_TOKEN` in your environment or call `huggingface_hub.login()` first. The token needs **write** access to the Space.
+`hf sync` is **incremental** — it computes checksums and only uploads files that have changed.
+
+### Step 3 — Download the Bucket to Another Machine
 
-### Method 3: Hugging Face Hub UI (quick one-off uploads)
+To pull the latest bucket contents back to a local `./data` folder (e.g., on a new dev machine):
+
+```bash
+hf sync hf://buckets/millimanfrance/Example-App-Hackathon-Gustave-Eiffel-2026-storage ./data
+```
 
-1. Open your Space repository on huggingface.co
-2. Navigate to **Files and versions**
-3. Click **Add file → Upload files**
-4. Drag-and-drop your binary files (up to 50 GB per file via the UI)
-5. Commit directly to `main`
+### Accessing Files in the Space Application
 
-### Accessing Uploaded Files in Your Application
+Once the bucket is mounted, files appear under `/data` inside the Space container regardless of their path in the bucket.
 
-Once binary files are in the repo (via any method above), they are available at their relative path inside the Space container:
+The application resolves this automatically via a single `DATA_DIR` constant in `app.py`:
 
 ```python
-import chromadb
+from pathlib import Path
+
+# /data when running in HF Spaces (bucket mount), ./data for local dev
+DATA_DIR = Path("/data") if Path("/data").is_dir() else Path("./data")
 
-# Files land at the repo root, same relative path you committed them at
-client = chromadb.PersistentClient(path="./chroma_db")
+CHROMA_PERSIST_DIR = str(DATA_DIR / "chroma_db")
+SAMPLE_DOCS_DIR = DATA_DIR / "sample_documents"
 ```
 
-No extra download logic is needed — Hugging Face clones the full repo (including LFS objects) into the Space container on startup.
+All persistent data — the vector store, sample documents, datasets — lives under `DATA_DIR` so a single `hf sync ./data ...` covers everything.
 
-### Tips
+### Useful `hf sync` Flags
 
-- **`.gitattributes`** is the source of truth for LFS tracking. Verify your patterns are listed there before pushing.
-- For files **> 5 GB**, prefer uploading via the Hub UI or the SDK (Git LFS CLI may time out on slow connections).
-- If you update a binary file, push the new version the same way — LFS handles versioning automatically.
-- To exclude files from the Space build (e.g., test data not needed at runtime), add them to `.gitignore` instead.
+| Flag | Description |
+|---|---|
+| `--include "*.pdf"` | Only sync files matching the pattern |
+| `--exclude "*.tmp"` | Skip files matching the pattern |
+| `--delete` | Remove files in the destination that no longer exist in the source |
+| `--dry-run` | Preview what would be transferred without actually doing it |
+
+```bash
+# Preview before committing
+hf sync ./data hf://buckets/millimanfrance/Example-App-Hackathon-Gustave-Eiffel-2026-storage --dry-run
+```
 
 ---
 
@@ -429,7 +441,9 @@ No extra download logic is needed — Hugging Face clones the full repo (includi
 | `HF_TOKEN` | (Space Secret) | Hugging Face API token for Inference API |
 | `EMBEDDING_MODEL_NAME` | `sentence-transformers/all-MiniLM-L6-v2` | Model for text embeddings |
 | `LLM_MODEL_NAME` | `Qwen/Qwen2.5-72B-Instruct` | LLM for answer generation |
-| `CHROMA_PERSIST_DIR` | `./chroma_db` | ChromaDB storage path |
+| `DATA_DIR` | `/data` (HF Spaces) or `./data` (local) | Root directory for all persistent data |
+| `CHROMA_PERSIST_DIR` | `DATA_DIR/chroma_db` | ChromaDB storage path |
+| `SAMPLE_DOCS_DIR` | `DATA_DIR/sample_documents` | Documents ingested on startup |
 | `CHUNK_SIZE` | `512` | Text chunk size in characters |
 | `CHUNK_OVERLAP` | `50` | Overlap between chunks |
 | `TOP_K_RESULTS` | `3` | Number of context chunks to retrieve |
@@ -507,6 +521,84 @@ Set the variable **before** running `python app.py`. Both `huggingface_hub` and
 > **How to export your corporate CA certificate:**
 > Open the failing URL (`https://huggingface.co`) in your browser, click the padlock icon → View Certificate → export the root CA as a `.crt` / `.pem` file, then point `REQUESTS_CA_BUNDLE` to that file.
 
+### `hf sync` 401 Unauthorized Error
+
+If `hf sync` fails with:
+
+```
+Error: Client error '401 Unauthorized' for url
+'https://huggingface.co/api/buckets/.../tree?recursive=true'
+Invalid username or password.
+```
+
+the `hf` CLI has not been authenticated. Log in with your Hugging Face token:
+
+```bash
+hf auth login
+# Paste your token when prompted (needs read + write access to the bucket)
+```
+
+Or set the token as an environment variable so the CLI picks it up automatically without an interactive prompt:
+
+```bash
+export HF_TOKEN="hf_your_token_here"
+hf sync ./data hf://buckets/millimanfrance/Example-App-Hackathon-Gustave-Eiffel-2026-storage
+```
+
+> **Generate a token:** Go to huggingface.co → Settings → Access Tokens → New token. Select **Write** role so the CLI can both read and upload to the bucket.
+
+> **Check current login state:**
+> ```bash
+> hf auth whoami
+> ```
+
+---
+
+### `hf sync` SSL Certificate Verification Error
+
+The `hf` CLI (installed via `uv tool install huggingface_hub`) uses `httpx` internally instead of `requests`, so it ignores `REQUESTS_CA_BUNDLE`. If `hf sync` fails with:
+
+```
+httpcore.ConnectError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed:
+unable to get local issuer certificate
+```
+
+you must set the certificate bundle through the variables that `httpx` (and the underlying `ssl` module) respects:
+
+```bash
+# Option A — point to your corporate CA bundle file (recommended)
+export SSL_CERT_FILE=/path/to/corporate-ca.crt
+export REQUESTS_CA_BUNDLE=/path/to/corporate-ca.crt   # keep this too for other tools
+
+hf sync ./data hf://buckets/millimanfrance/Example-App-Hackathon-Gustave-Eiffel-2026-storage
+
+# Option B — append your CA cert to the system bundle and point there
+cat /path/to/corporate-ca.crt >> /etc/ssl/certs/ca-certificates.crt
+export SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt
+```
+
+`SSL_CERT_FILE` overrides the default CA store for Python's `ssl` module, which `httpx` / `httpcore` uses directly.
+
+**If you need to set these variables permanently** (e.g., in a shared dev environment), add them to your shell profile:
+
+```bash
+# ~/.bashrc or ~/.zshrc
+export SSL_CERT_FILE=/path/to/corporate-ca.crt
+export REQUESTS_CA_BUNDLE=/path/to/corporate-ca.crt
+```
+
+> **Finding your corporate CA cert on Linux:**
+> ```bash
+> # List all trusted CAs and look for your company's entry
+> awk -v cmd='openssl x509 -noout -subject' '/BEGIN CERT/{close(cmd)}; {print | cmd}' \
+>   /etc/ssl/certs/ca-certificates.crt | grep -i "your-company-name"
+>
+> # Or export the cert directly from the proxy
+> echo | openssl s_client -connect huggingface.co:443 -showcerts 2>/dev/null \
+>   | openssl x509 -outform PEM > /tmp/hf-chain.pem
+> export SSL_CERT_FILE=/tmp/hf-chain.pem
+> ```
+
 ---
 
 ## License

app.py

@@ -32,7 +32,6 @@ from fastapi.responses import JSONResponse
 from pydantic import BaseModel
 import chromadb
 from chromadb.config import Settings
-from sentence_transformers import SentenceTransformer
 from langchain_text_splitters import RecursiveCharacterTextSplitter
 from pypdf import PdfReader
 
@@ -46,42 +45,49 @@ logging.getLogger("chromadb.telemetry.product.posthog").setLevel(logging.CRITICA
 # Configuration
 # ---------------------------------------------------------------------------
 
-EMBEDDING_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
-CHROMA_PERSIST_DIR = "./chroma_db"
+# Resolve the data directory: /data when running inside HF Spaces (bucket mount),
+# ./data for local development.
+DATA_DIR = Path("/data") if Path("/data").is_dir() else Path("./data")
+
+CHROMA_PERSIST_DIR = str(DATA_DIR / "chroma_db")
+SAMPLE_DOCS_DIR = DATA_DIR / "sample_documents"
 COLLECTION_NAME = "rag_documents"
 CHUNK_SIZE = 512
 CHUNK_OVERLAP = 50
 TOP_K_RESULTS = 3
 
-# LLM settings loaded from config.json
+# Settings loaded from config.json
 _CONFIG_PATH = Path(__file__).parent / "config.json"
 with open(_CONFIG_PATH, encoding="utf-8") as _f:
     _config = json.load(_f)
 
+# Embedding model (Azure OpenAI)
+EMBEDDING_ENDPOINT_URL = _config["embedding"]["endpoint_url"]
+EMBEDDING_MODEL_NAME = _config["embedding"]["model"]
+
+# LLM (Azure OpenAI)
 LLM_ENDPOINT_URL = _config["llm"]["endpoint_url"]
 LLM_MODEL_NAME = _config["llm"]["model"]
 LLM_MAX_TOKENS = _config["llm"].get("max_tokens", 512)
 LLM_TEMPERATURE = _config["llm"].get("temperature", 0.7)
 LLM_TOP_P = _config["llm"].get("top_p", 0.95)
 
-# Azure Foundry API key from environment variable
+# Azure API key from environment variable (shared by both LLM and embedding endpoints)
 AZURE_API_KEY = os.environ.get("AZURE_API_KEY")
 if not AZURE_API_KEY:
-    logger.warning("AZURE_API_KEY is not set — LLM calls will fail.")
+    logger.warning("AZURE_API_KEY is not set — LLM and embedding calls will fail.")
 
 # Prompt template loaded from file so it can be edited without touching application code
 _PROMPT_TEMPLATE_PATH = Path(__file__).parent / "prompts" / "rag_prompt.txt"
 RAG_PROMPT_TEMPLATE = _PROMPT_TEMPLATE_PATH.read_text(encoding="utf-8")
 
 # ---------------------------------------------------------------------------
-# Step 1: Initialize the Embedding Model
+# Step 1: Embedding via Azure OpenAI
 # ---------------------------------------------------------------------------
-# We use sentence-transformers to convert text chunks into dense vector embeddings.
-# The model runs locally inside the Space — no external API call needed.
+# Embeddings are generated by calling the Azure OpenAI /embeddings endpoint.
+# No local model is loaded — the API handles all inference.
 
-logger.info(f"Loading embedding model: {EMBEDDING_MODEL_NAME}")
-embedding_model = SentenceTransformer(EMBEDDING_MODEL_NAME)
-logger.info("Embedding model loaded successfully.")
+logger.info(f"Embedding model configured: {EMBEDDING_MODEL_NAME} via Azure OpenAI")
 
 # ---------------------------------------------------------------------------
 # Step 2: Initialize the Vector Store (ChromaDB)
@@ -152,13 +158,32 @@ def chunk_text(text: str, source: str = "unknown") -> list[dict]:
 
 def generate_embeddings(texts: list[str]) -> list[list[float]]:
     """
-    Transform text chunks into vector embeddings using sentence-transformers.
+    Generate vector embeddings via the Azure OpenAI /embeddings endpoint.
 
-    This demonstrates Step 2a: How to convert documents into embeddings.
-    The model maps each text string to a 384-dimensional dense vector.
+    The endpoint, model name, and API key are loaded from config.json
+    and the AZURE_API_KEY environment variable.
     """
-    embeddings = embedding_model.encode(texts, show_progress_bar=False)
-    return embeddings.tolist()
+    headers = {
+        "api-key": AZURE_API_KEY,
+        "Content-Type": "application/json",
+    }
+    payload = {
+        "input": texts,
+        "model": EMBEDDING_MODEL_NAME,
+    }
+    try:
+        resp = http_requests.post(
+            EMBEDDING_ENDPOINT_URL, headers=headers, json=payload, timeout=60,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        return [item["embedding"] for item in data["data"]]
+    except http_requests.exceptions.HTTPError as e:
+        logger.error(f"Embedding API call failed: {e} — {resp.text}")
+        raise HTTPException(status_code=503, detail=f"Embedding service unavailable: {str(e)}")
+    except (KeyError, IndexError) as e:
+        logger.error(f"Unexpected embedding response format: {e}")
+        raise HTTPException(status_code=502, detail="Unexpected response from embedding service")
 
 
 def add_documents_to_vectorstore(documents: list[dict]) -> int:
@@ -311,8 +336,6 @@ def rag_query(query: str, top_k: int = TOP_K_RESULTS) -> dict:
 # ---------------------------------------------------------------------------
 # Load sample documents so the demo works out of the box.
 
-SAMPLE_DOCS_DIR = Path("./sample_documents")
-
 
 def ingest_sample_documents():
     """Load and embed sample documents into the vector store on first run."""

config.json

@@ -1,4 +1,8 @@
 {
+    "embedding": {
+        "endpoint_url": "https://<your-resource>.openai.azure.com/openai/deployments/<your-embedding-deployment>/embeddings?api-version=2024-12-01-preview",
+        "model": "text-embedding-3-small"
+    },
     "llm": {
         "endpoint_url": "https://<your-resource>.openai.azure.com/openai/deployments/<your-deployment>/chat/completions?api-version=2024-12-01-preview",
         "model": "gpt-5",

requirements.txt

@@ -2,7 +2,6 @@ fastapi==0.115.0
 uvicorn==0.30.0
 gradio==4.44.0
 chromadb==0.5.0
-sentence-transformers==3.0.0
 huggingface-hub==0.25.0
 langchain==0.3.0
 langchain-community==0.3.0

team.yml

@@ -0,0 +1,6 @@
+display_name: "Sample Team Name"
+members:
+  - name: "Quincy"
+    email: "quincy@example.com"
+  - name: "Alice"
+    email: "alice@example.com"