Spaces:
Running
Running
Download app/main.py from 2Btainment/Fuugi-API: direct link, hf CLI and curl.
- Browser
- Download file 13.7 kB
-
https://huggingface.co/spaces/2Btainment/Fuugi-API/resolve/main/app/main.py
- Command line
-
hf download hf://spaces/2Btainment/Fuugi-API/app/main.py
-
curl -L -o main.py https://huggingface.co/spaces/2Btainment/Fuugi-API/resolve/main/app/main.py
13.7 kB
| from __future__ import annotations | |
| import logging | |
| from collections.abc import AsyncIterator | |
| from contextlib import asynccontextmanager | |
| import httpx | |
| from fastapi import FastAPI, HTTPException, Request, Response | |
| from fastapi.exceptions import RequestValidationError | |
| from fastapi.middleware.cors import CORSMiddleware | |
| from fastapi.responses import JSONResponse | |
| from app.config import Settings | |
| from app.knowledge import system_prompt | |
| from app.memory import ( | |
| InvalidMemorySession, | |
| MemoryConsentRequired, | |
| MemoryLimitReached, | |
| MemoryRecord, | |
| MemoryStore, | |
| SensitiveMemoryRejected, | |
| extract_explicit_memory, | |
| ) | |
| from app.models import ( | |
| FuugiRequest, | |
| FuugiResponse, | |
| MemoryConsentRequest, | |
| MemoryEvent, | |
| MemoryItem, | |
| MemoryListResponse, | |
| ) | |
| from app.openrouter import OpenRouterClient, OpenRouterNotConfigured, OpenRouterUnavailable | |
| from app.worker import WorkerClient, WorkerNotConfigured, WorkerUnavailable | |
| from app.research import ResearchStore, ResearchWriteError, classify_research | |
| from app.security import ( | |
| BodySizeLimitMiddleware, | |
| SlidingWindowRateLimiter, | |
| client_identity, | |
| request_messages, | |
| ) | |
| logger = logging.getLogger(__name__) | |
| def create_app( | |
| settings: Settings | None = None, | |
| transport: httpx.AsyncBaseTransport | None = None, | |
| worker_transport: httpx.AsyncBaseTransport | None = None, | |
| ) -> FastAPI: | |
| active_settings = settings or Settings.from_env() | |
| memory_store = ( | |
| MemoryStore( | |
| database_path=active_settings.memory_database_path, | |
| pepper=active_settings.memory_session_pepper, | |
| retention_days=active_settings.memory_retention_days, | |
| max_items=active_settings.memory_max_items, | |
| max_item_characters=active_settings.memory_max_item_characters, | |
| max_context_characters=active_settings.memory_max_context_characters, | |
| ) | |
| if active_settings.memory_enabled | |
| else None | |
| ) | |
| research_store = ( | |
| ResearchStore( | |
| database_path=active_settings.market_research_database_path, | |
| retention_days=active_settings.market_research_retention_days, | |
| ) | |
| if active_settings.market_research_enabled | |
| else None | |
| ) | |
| async def lifespan(application: FastAPI) -> AsyncIterator[None]: | |
| client = OpenRouterClient(active_settings, transport=transport) | |
| worker = WorkerClient(active_settings, transport=worker_transport) | |
| application.state.openrouter = client | |
| application.state.worker = worker | |
| try: | |
| yield | |
| finally: | |
| await worker.close() | |
| await client.close() | |
| application = FastAPI( | |
| title="Fuugi Companion API", | |
| version="1.0.0", | |
| docs_url=None, | |
| redoc_url=None, | |
| openapi_url=None, | |
| lifespan=lifespan, | |
| ) | |
| application.state.settings = active_settings | |
| application.state.memory = memory_store | |
| application.state.research = research_store | |
| application.state.rate_limiter = SlidingWindowRateLimiter( | |
| active_settings.rate_limit_requests, | |
| active_settings.rate_limit_window_seconds, | |
| ) | |
| application.add_middleware( | |
| CORSMiddleware, | |
| allow_origins=list(active_settings.allowed_origins), | |
| allow_credentials=False, | |
| allow_methods=["GET", "POST", "DELETE", "OPTIONS"], | |
| allow_headers=["Accept", "Content-Type", "X-Fuugi-Session"], | |
| max_age=600, | |
| ) | |
| application.add_middleware( | |
| BodySizeLimitMiddleware, | |
| max_body_bytes=active_settings.max_body_bytes, | |
| ) | |
| async def invalid_request(_request: Request, _error: RequestValidationError) -> JSONResponse: | |
| return JSONResponse({"detail": "Invalid request."}, status_code=400) | |
| async def enforce_rate_limit(request: Request) -> None: | |
| limiter: SlidingWindowRateLimiter = request.app.state.rate_limiter | |
| allowed, retry_after = await limiter.check(client_identity(request, active_settings)) | |
| if not allowed: | |
| raise HTTPException( | |
| status_code=429, | |
| detail="Too many requests.", | |
| headers={"Retry-After": str(retry_after)}, | |
| ) | |
| async def health() -> dict[str, str | bool]: | |
| worker_on = bool( | |
| active_settings.fuugi_worker_url and active_settings.fuugi_worker_token | |
| ) | |
| return { | |
| "status": "ok", | |
| "service": "fuugi-api", | |
| "source": "fuugi-worker" if worker_on else "openrouter", | |
| "model": "fuugi-worker" if worker_on else active_settings.primary_model, | |
| "upstream_configured": bool(active_settings.openrouter_api_key), | |
| "worker_configured": worker_on, | |
| } | |
| def memory_access(request: Request) -> tuple[MemoryStore, str]: | |
| store: MemoryStore | None = request.app.state.memory | |
| if store is None: | |
| raise HTTPException(status_code=404, detail="Memory is not enabled.") | |
| token = request.headers.get("x-fuugi-session", "").strip() | |
| if not token: | |
| raise HTTPException(status_code=400, detail="Memory session is required.") | |
| return store, token | |
| def memory_items(records: list[MemoryRecord]) -> list[MemoryItem]: | |
| return [ | |
| MemoryItem( | |
| id=record.id, | |
| content=record.content, | |
| created_at=record.created_at, | |
| expires_at=record.expires_at, | |
| ) | |
| for record in records | |
| ] | |
| async def fuugi_info(request: Request) -> FuugiResponse: | |
| await enforce_rate_limit(request) | |
| return FuugiResponse( | |
| content="Fuugi companion API is online. POST the widget JSON payload to this endpoint.", | |
| source="api", | |
| model=active_settings.primary_model, | |
| ) | |
| async def fuugi_options() -> Response: | |
| return Response(status_code=204) | |
| async def memory_consent( | |
| payload: MemoryConsentRequest, request: Request | |
| ) -> MemoryListResponse: | |
| await enforce_rate_limit(request) | |
| store, token = memory_access(request) | |
| try: | |
| enabled = await store.set_consent(token, payload.enabled) | |
| _, records = await store.list(token) | |
| except InvalidMemorySession as error: | |
| raise HTTPException(status_code=400, detail="Invalid memory session.") from error | |
| return MemoryListResponse( | |
| enabled=enabled, | |
| memories=memory_items(records), | |
| ) | |
| async def list_memories(request: Request) -> MemoryListResponse: | |
| await enforce_rate_limit(request) | |
| store, token = memory_access(request) | |
| try: | |
| enabled, records = await store.list(token) | |
| except InvalidMemorySession as error: | |
| raise HTTPException(status_code=400, detail="Invalid memory session.") from error | |
| return MemoryListResponse( | |
| enabled=enabled, | |
| memories=memory_items(records), | |
| ) | |
| async def clear_memories(request: Request) -> MemoryListResponse: | |
| await enforce_rate_limit(request) | |
| store, token = memory_access(request) | |
| try: | |
| await store.clear(token) | |
| enabled, _ = await store.list(token) | |
| except InvalidMemorySession as error: | |
| raise HTTPException(status_code=400, detail="Invalid memory session.") from error | |
| return MemoryListResponse(enabled=enabled, memories=[]) | |
| async def delete_memory(memory_id: str, request: Request) -> Response: | |
| await enforce_rate_limit(request) | |
| store, token = memory_access(request) | |
| try: | |
| deleted = await store.delete(token, memory_id) | |
| except InvalidMemorySession as error: | |
| raise HTTPException(status_code=400, detail="Invalid memory reference.") from error | |
| if not deleted: | |
| raise HTTPException(status_code=404, detail="Memory not found.") | |
| return Response(status_code=204) | |
| async def fuugi_chat(payload: FuugiRequest, request: Request) -> FuugiResponse: | |
| await enforce_rate_limit(request) | |
| store: MemoryStore | None = request.app.state.memory | |
| token = request.headers.get("x-fuugi-session", "").strip() | |
| explicit_memory = extract_explicit_memory(payload.message) | |
| if explicit_memory is not None: | |
| if store is None: | |
| return FuugiResponse( | |
| content="Der Lernspeicher ist auf diesem Server nicht aktiviert.", | |
| source="memory", | |
| model="local-memory-v1", | |
| memory_event=MemoryEvent(status="unavailable"), | |
| ) | |
| if not token: | |
| return FuugiResponse( | |
| content=( | |
| "Aktiviere zuerst den Lernspeicher im Chat, damit ich das speichern darf." | |
| ), | |
| source="memory", | |
| model="local-memory-v1", | |
| memory_event=MemoryEvent(status="consent_required"), | |
| ) | |
| try: | |
| record = await store.add(token, explicit_memory) | |
| except MemoryConsentRequired: | |
| return FuugiResponse( | |
| content=( | |
| "Aktiviere zuerst den Lernspeicher im Chat, damit ich das speichern darf." | |
| ), | |
| source="memory", | |
| model="local-memory-v1", | |
| memory_event=MemoryEvent(status="consent_required"), | |
| ) | |
| except (MemoryLimitReached, SensitiveMemoryRejected): | |
| return FuugiResponse( | |
| content=( | |
| "Das speichere ich nicht. Nutze kurze, nicht sensible Angaben und keine " | |
| "Passwörter, Schlüssel oder Zahlungsdaten." | |
| ), | |
| source="memory", | |
| model="local-memory-v1", | |
| memory_event=MemoryEvent(status="rejected"), | |
| ) | |
| except InvalidMemorySession as error: | |
| raise HTTPException(status_code=400, detail="Invalid memory session.") from error | |
| return FuugiResponse( | |
| content="Gemerkt. Du kannst diese Erinnerung jederzeit ansehen oder löschen.", | |
| source="memory", | |
| model="local-memory-v1", | |
| memory_event=MemoryEvent(status="saved", id=record.id), | |
| ) | |
| memories: list[str] = [] | |
| if store is not None and token: | |
| try: | |
| memories = await store.context(token) | |
| except InvalidMemorySession as error: | |
| raise HTTPException(status_code=400, detail="Invalid memory session.") from error | |
| try: | |
| messages = request_messages(payload, active_settings, system_prompt(), memories) | |
| except ValueError as error: | |
| raise HTTPException(status_code=400, detail="Invalid request.") from error | |
| worker: WorkerClient = request.app.state.worker | |
| completion = None | |
| source = "openrouter" | |
| if worker.configured: | |
| try: | |
| completion = await worker.complete(messages) | |
| source = "fuugi-worker" | |
| except WorkerNotConfigured: | |
| completion = None | |
| except WorkerUnavailable: | |
| logger.warning("Fuugi worker unavailable; trying OpenRouter fallback.") | |
| if completion is None: | |
| client: OpenRouterClient = request.app.state.openrouter | |
| try: | |
| completion = await client.complete(messages) | |
| source = "openrouter" | |
| except OpenRouterNotConfigured as error: | |
| raise HTTPException( | |
| status_code=503, detail="Service temporarily unavailable." | |
| ) from error | |
| except OpenRouterUnavailable as error: | |
| raise HTTPException( | |
| status_code=502, detail="Upstream service temporarily unavailable." | |
| ) from error | |
| research: ResearchStore | None = request.app.state.research | |
| if research is not None: | |
| research_text = payload.message | |
| if not research_text: | |
| research_text = next( | |
| ( | |
| item.content | |
| for item in reversed(payload.messages) | |
| if item.role == "user" | |
| ), | |
| "", | |
| ) | |
| if research_text: | |
| topic, intent = classify_research(research_text) | |
| try: | |
| await research.increment(topic, intent) | |
| except ResearchWriteError: | |
| logger.warning("Anonymous research counter update failed.") | |
| return FuugiResponse( | |
| content=completion.content, | |
| source=source, | |
| model=completion.model, | |
| ) | |
| return application | |
| app = create_app() | |