feat: FastAPI vLLM service with OpenAI-compatible endpoints and PRIIPs extractor

.gitignore

@@ -0,0 +1,15 @@
+__pycache__/
+.pytest_cache/
+.venv/
+*.pyc
+*.pyo
+*.pyd
+.DS_Store
+.env
+.env.*
+dist/
+build/
+*.log
+*.sqlite3
+*.db
+

README.md

@@ -0,0 +1,52 @@
+# PRIIPs LLM Service (vLLM + FastAPI)
+
+OpenAI-compatible API and PRIIPs extractor powered by `DragonLLM/LLM-Pro-Finance-Small` via vLLM.
+
+## Setup
+
+1. Create and activate a virtualenv (optional)
+2. Install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+3. Configure environment:
+
+- Copy `.env.example` to `.env` and adjust values
+- Ensure your vLLM server is running and has `HUGGING_FACE_HUB_TOKEN` set so it can pull the model
+
+Start vLLM (example):
+
+```bash
+HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \
+python -m vllm.entrypoints.openai.api_server \
+  --model DragonLLM/LLM-Pro-Finance-Small \
+  --host 0.0.0.0 --port 8000
+```
+
+Run the FastAPI app:
+
+```bash
+uvicorn app.main:app --reload --port 8080
+```
+
+## OpenAI-compatible API
+
+- GET `/v1/models`
+- POST `/v1/chat/completions` (supports `stream=true` if vLLM streaming enabled)
+
+Point PydanticAI/DSPy to `http://localhost:8080/v1` as the base.
+
+## PRIIPs extraction
+
+- POST `/extract-priips` with body:
+
+```json
+{
+  "sources": ["https://example.com/doc.pdf"],
+  "options": {"language": "en", "ocr": false}
+}
+```
+
+Returns structured JSON validated by Pydantic.

app/__init__.py

@@ -0,0 +1,2 @@
+# empty package marker
+

app/config.py

@@ -0,0 +1,17 @@
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    vllm_base_url: str = "http://localhost:8000/v1"
+    model: str = "DragonLLM/LLM-Pro-Finance-Small"
+    service_api_key: str | None = None
+    log_level: str = "info"
+
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+
+
+settings = Settings()
+
+

app/main.py

@@ -0,0 +1,21 @@
+from fastapi import FastAPI
+from app.middleware import api_key_guard
+
+from app.routers import openai_api, extract
+
+
+app = FastAPI(title="PRIIPs LLM Service (vLLM)")
+
+# Mount routers
+app.include_router(openai_api.router, prefix="/v1")
+app.include_router(extract.router)
+
+# Optional API key middleware
+app.middleware("http")(api_key_guard)
+
+
+@app.get("/")
+async def root():
+    return {"status": "ok"}
+
+

app/middleware.py

@@ -0,0 +1,15 @@
+from fastapi import Request, HTTPException
+from fastapi.responses import JSONResponse
+
+from app.config import settings
+
+
+async def api_key_guard(request: Request, call_next):
+    if not settings.service_api_key:
+        return await call_next(request)
+    key = request.headers.get("x-api-key") or request.headers.get("authorization")
+    if key and key.replace("Bearer ", "").strip() == settings.service_api_key:
+        return await call_next(request)
+    return JSONResponse({"error": "unauthorized"}, status_code=401)
+
+

app/models/openai.py

@@ -0,0 +1,46 @@
+from typing import List, Literal, Optional
+from pydantic import BaseModel, Field
+
+
+Role = Literal["system", "user", "assistant", "tool"]
+
+
+class Message(BaseModel):
+    role: Role
+    content: str
+
+
+class ChatCompletionRequest(BaseModel):
+    model: str
+    messages: List[Message]
+    temperature: Optional[float] = 0.2
+    max_tokens: Optional[int] = Field(default=None, alias="max_tokens")
+    stream: Optional[bool] = False
+
+
+class ChoiceMessage(BaseModel):
+    role: Literal["assistant"]
+    content: Optional[str] = None
+
+
+class Choice(BaseModel):
+    index: int
+    message: ChoiceMessage
+    finish_reason: Optional[str] = None
+
+
+class Usage(BaseModel):
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+
+
+class ChatCompletionResponse(BaseModel):
+    id: str
+    object: Literal["chat.completion"] = "chat.completion"
+    created: int
+    model: str
+    choices: List[Choice]
+    usage: Optional[Usage] = None
+
+

app/models/priips.py

@@ -0,0 +1,41 @@
+from typing import List, Optional
+from pydantic import BaseModel
+
+
+class PerformanceScenario(BaseModel):
+    name: str
+    description: Optional[str] = None
+    return_pct: Optional[float] = None
+
+
+class Costs(BaseModel):
+    entry_cost_pct: Optional[float] = None
+    ongoing_cost_pct: Optional[float] = None
+    exit_cost_pct: Optional[float] = None
+
+
+class PriipsFields(BaseModel):
+    product_name: Optional[str] = None
+    manufacturer: Optional[str] = None
+    isin: Optional[str] = None
+    sri: Optional[int] = None
+    recommended_holding_period: Optional[str] = None
+    costs: Optional[Costs] = None
+    performance_scenarios: Optional[List[PerformanceScenario]] = None
+    date: Optional[str] = None
+    language: Optional[str] = None
+    source_url: Optional[str] = None
+
+
+class ExtractRequest(BaseModel):
+    sources: List[str]
+    options: Optional[dict] = None
+
+
+class ExtractResult(BaseModel):
+    source: str
+    success: bool
+    data: Optional[PriipsFields] = None
+    error: Optional[str] = None
+
+

app/providers/base.py

@@ -0,0 +1,11 @@
+from typing import Protocol, Dict, Any
+
+
+class LLMProvider(Protocol):
+    async def list_models(self) -> Dict[str, Any]:
+        ...
+
+    async def chat(self, payload: Dict[str, Any], stream: bool = False) -> Any:
+        ...
+
+

app/providers/vllm.py

@@ -0,0 +1,24 @@
+import httpx
+from app.config import settings
+
+
+async def list_models():
+    async with httpx.AsyncClient(timeout=30) as client:
+        r = await client.get(f"{settings.vllm_base_url}/models")
+        r.raise_for_status()
+        return r.json()
+
+
+async def chat(payload, stream: bool = False):
+    async with httpx.AsyncClient(timeout=None) as client:
+        if stream:
+            return await client.stream(
+                "POST", f"{settings.vllm_base_url}/chat/completions", json=payload
+            )
+        r = await client.post(
+            f"{settings.vllm_base_url}/chat/completions", json=payload
+        )
+        r.raise_for_status()
+        return r.json()
+
+

app/routers/__init__.py

@@ -0,0 +1,2 @@
+# package
+

app/routers/extract.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+
+from app.models.priips import ExtractRequest
+from app.services import extract_service
+
+
+router = APIRouter()
+
+
+@router.post("/extract-priips")
+async def extract_priips(body: ExtractRequest):
+    return await extract_service.extract(body)
+
+

app/routers/openai_api.py

@@ -0,0 +1,49 @@
+import time
+from typing import Any, Dict
+
+from fastapi import APIRouter
+from fastapi.responses import StreamingResponse, JSONResponse
+
+from app.config import settings
+from app.models.openai import ChatCompletionRequest
+from app.services import chat_service
+
+
+router = APIRouter()
+
+
+@router.get("/models")
+async def list_models():
+    return await chat_service.list_models()
+
+
+@router.post("/chat/completions")
+async def chat_completions(body: ChatCompletionRequest):
+    payload: Dict[str, Any] = {
+        "model": body.model or settings.model,
+        "messages": [m.model_dump() for m in body.messages],
+        "temperature": body.temperature,
+        **({"max_tokens": body.max_tokens} if body.max_tokens is not None else {}),
+        "stream": body.stream or False,
+    }
+
+    if body.stream:
+        upstream = await chat_service.chat(payload, stream=True)
+
+        async def event_stream():
+            async for line in upstream.aiter_lines():
+                if not line:
+                    continue
+                if line.startswith("data:"):
+                    yield f"{line}\n\n"
+                else:
+                    yield f"data: {line}\n\n"
+
+        return StreamingResponse(event_stream(), media_type="text/event-stream")
+
+    data = await chat_service.chat(payload, stream=False)
+    # Assume vLLM already returns OpenAI-compatible schema; pass through.
+    # If needed, normalize here.
+    return JSONResponse(content=data)
+
+

app/services/chat_service.py

@@ -0,0 +1,13 @@
+from typing import Any, Dict
+
+from app.providers import vllm as provider
+
+
+async def list_models() -> Dict[str, Any]:
+    return await provider.list_models()
+
+
+async def chat(payload: Dict[str, Any], stream: bool = False):
+    return await provider.chat(payload, stream=stream)
+
+

app/services/extract_service.py

@@ -0,0 +1,86 @@
+import json
+from pathlib import Path
+from typing import List
+
+from app.config import settings
+from app.models.priips import ExtractRequest, ExtractResult, PriipsFields
+from app.providers import vllm
+from app.utils.pdf import download_to_tmp, extract_text_from_pdf
+from app.utils.json_guard import try_parse_json
+
+
+def build_prompt(text: str) -> str:
+    schema = {
+        "product_name": "string",
+        "manufacturer": "string",
+        "isin": "string",
+        "sri": "integer (1-7)",
+        "recommended_holding_period": "string",
+        "costs": {
+            "entry_cost_pct": "number?",
+            "ongoing_cost_pct": "number?",
+            "exit_cost_pct": "number?",
+        },
+        "performance_scenarios": [
+            {"name": "string", "description": "string?", "return_pct": "number?"}
+        ],
+        "date": "string?",
+        "language": "string?",
+        "source_url": "string?",
+    }
+    instruction = (
+        "You are an expert financial document parser. "
+        "Extract the requested PRIIPs fields as STRICT JSON only, no extra text. "
+        f"JSON schema keys: {list(schema.keys())}."
+    )
+    return f"{instruction}\n\nDocument:\n{text[:15000]}"
+
+
+async def process_source(src: str) -> ExtractResult:
+    try:
+        path: Path
+        if src.lower().startswith("http"):
+            path = await download_to_tmp(src, Path(".tmp"))
+        else:
+            path = Path(src)
+        text = extract_text_from_pdf(path)
+        prompt = build_prompt(text)
+
+        payload = {
+            "model": settings.model,
+            "messages": [
+                {"role": "system", "content": "You output JSON only."},
+                {"role": "user", "content": prompt},
+            ],
+            "temperature": 0.1,
+            "max_tokens": 800,
+            "stream": False,
+        }
+        data = await vllm.chat(payload, stream=False)
+
+        # vLLM OpenAI response
+        content = (
+            data.get("choices", [{}])[0]
+            .get("message", {})
+            .get("content", "")
+            if isinstance(data, dict)
+            else ""
+        )
+        ok, parsed = try_parse_json(content)
+        if not ok:
+            return ExtractResult(source=src, success=False, error=str(parsed))
+
+        model_data = PriipsFields(**parsed)
+        model_data.source_url = src
+        return ExtractResult(source=src, success=True, data=model_data)
+    except Exception as e:
+        return ExtractResult(source=src, success=False, error=str(e))
+
+
+async def extract(req: ExtractRequest) -> List[ExtractResult]:
+    results: List[ExtractResult] = []
+    for src in req.sources:
+        results.append(await process_source(src))
+    return results
+
+

app/utils/json_guard.py

@@ -0,0 +1,18 @@
+import json
+from typing import Any, Tuple
+
+
+def try_parse_json(text: str) -> Tuple[bool, Any]:
+    try:
+        return True, json.loads(text)
+    except Exception:
+        # naive repair: strip markdown fences if present
+        t = text.strip()
+        if t.startswith("```") and t.endswith("```"):
+            t = t.strip("`\n ")
+        try:
+            return True, json.loads(t)
+        except Exception as e:
+            return False, str(e)
+
+

app/utils/pdf.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+from typing import Optional
+
+import httpx
+import fitz  # PyMuPDF
+
+
+async def download_to_tmp(url: str, tmp_dir: Path) -> Path:
+    tmp_dir.mkdir(parents=True, exist_ok=True)
+    filename = url.split("/")[-1] or "document.pdf"
+    target = tmp_dir / filename
+    async with httpx.AsyncClient(timeout=60) as client:
+        r = await client.get(url)
+        r.raise_for_status()
+        target.write_bytes(r.content)
+    return target
+
+
+def extract_text_from_pdf(path: Path) -> str:
+    doc = fitz.open(path)
+    try:
+        texts: list[str] = []
+        for page in doc:
+            texts.append(page.get_text("text"))
+        return "\n".join(texts).strip()
+    finally:
+        doc.close()
+
+

requirements.txt

@@ -0,0 +1,9 @@
+fastapi>=0.115.0
+uvicorn[standard]>=0.30.0
+pydantic>=2.8.0
+pydantic-settings>=2.4.0
+httpx>=0.27.0
+python-dotenv>=1.0.1
+tenacity>=8.3.0
+PyMuPDF>=1.24.0
+