"""FastAPI server for KG-based report generation.""" import json import logging import os from contextlib import asynccontextmanager from enum import Enum from fastapi import FastAPI, HTTPException from fastapi.middleware.cors import CORSMiddleware from pydantic import BaseModel, Field from api.kg_routes import get_companies_list, get_company_stats, run_kg_generation from config.rules import ( COMPANY_PRODUCT_RULE, FOUNDERS_TEAM_RULE, KEY_DEBATES_RULE, MARKET_CUSTOMER_SIGNALS_RULE, TAM_MARKET_RULE, ) from services.kg import KGClient from services.llm import GeminiLLM, LlmProvider, OpenAiLLM logger = logging.getLogger(__name__) # Section name to rule mapping SECTION_RULES = { "tam": TAM_MARKET_RULE, "product": COMPANY_PRODUCT_RULE, "customer_signals": MARKET_CUSTOMER_SIGNALS_RULE, "team": FOUNDERS_TEAM_RULE, "key_debates": KEY_DEBATES_RULE, } class SectionName(str, Enum): tam = "tam" product = "product" customer_signals = "customer_signals" team = "team" key_debates = "key_debates" class RetrievalMode(str, Enum): chunks = "chunks" full_documents = "full_documents" hybrid = "hybrid" class ModelProvider(str, Enum): gemini_flash = "gemini-2.0-flash" gemini_flash_lite = "gemini-2.0-flash-lite" gemini_pro = "gemini-2.5-pro-preview-05-06" gpt_4o = "gpt-4o" gpt_4o_mini = "gpt-4o-mini" # Request/Response models class GenerateReportRequest(BaseModel): company_id: str = Field(..., description="Company ID from the knowledge graph") section: SectionName = Field(..., description="Report section to generate") model: ModelProvider = Field( default=ModelProvider.gemini_flash_lite, description="LLM model to use" ) retrieval_mode: RetrievalMode = Field( default=RetrievalMode.hybrid, description="How to retrieve context from KG" ) extra_queries: list[str] | None = Field( default=None, description="Additional queries for retrieval" ) top_k: int = Field(default=40, ge=1, le=100, description="Number of chunks to retrieve") class CompanyResponse(BaseModel): id: str name: str class CompanyStatsResponse(BaseModel): doc_count: int chunk_count: int class GenerateReportResponse(BaseModel): success: bool section: str data: dict | None = None error: str | None = None # Global KG client (initialized on startup) _kg_client: KGClient | None = None def get_kg_client() -> KGClient: global _kg_client if _kg_client is None: supabase_url = os.environ.get("SUPABASE_URL") supabase_key = os.environ.get("SUPABASE_KEY") if not supabase_url or not supabase_key: raise HTTPException(status_code=500, detail="SUPABASE_URL and SUPABASE_KEY must be set") _kg_client = KGClient(supabase_url, supabase_key) return _kg_client def get_llm_provider(model: ModelProvider) -> LlmProvider: model_name = model.value if model_name.startswith("gemini"): api_key = os.environ.get("GEMINI_API_KEY") if not api_key: raise HTTPException(status_code=500, detail="GEMINI_API_KEY must be set") return GeminiLLM(api_key=api_key, model_name=model_name) else: api_key = os.environ.get("OPENAI_API_KEY") if not api_key: raise HTTPException(status_code=500, detail="OPENAI_API_KEY must be set") return OpenAiLLM(api_key=api_key, model_name=model_name) @asynccontextmanager async def lifespan(app: FastAPI): # Startup: initialize KG client logger.info("Starting up API server...") yield # Shutdown logger.info("Shutting down API server...") app = FastAPI( title="Day1 Report Generation API", description="API for generating due diligence reports from knowledge graph", version="0.1.0", lifespan=lifespan, ) # CORS middleware - configure for your frontend origin app.add_middleware( CORSMiddleware, allow_origins=["*"], # Update with your frontend URL in production allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) @app.get("/health") async def health_check(): return {"status": "ok"} @app.get("/companies", response_model=list[CompanyResponse]) async def list_companies(): """Get all companies available in the knowledge graph.""" kg_client = get_kg_client() companies = get_companies_list(kg_client) return companies @app.get("/companies/{company_id}/stats", response_model=CompanyStatsResponse) async def get_stats(company_id: str): """Get document and chunk counts for a company.""" kg_client = get_kg_client() stats = get_company_stats(kg_client, company_id) return stats @app.post("/reports/generate", response_model=GenerateReportResponse) async def generate_report(request: GenerateReportRequest): """Generate a report section for a company using KG data.""" kg_client = get_kg_client() llm_provider = get_llm_provider(request.model) rule = SECTION_RULES.get(request.section.value) if not rule: raise HTTPException(status_code=400, detail=f"Unknown section: {request.section}") result = run_kg_generation( rule=rule, llm_provider=llm_provider, kg_client=kg_client, company_id=request.company_id, extra_queries=request.extra_queries, retrieval_mode=request.retrieval_mode.value, top_k=request.top_k, ) if result is None: return GenerateReportResponse( success=False, section=request.section.value, error="Generation failed - check logs for details", ) try: data = json.loads(result) except json.JSONDecodeError: return GenerateReportResponse( success=False, section=request.section.value, error="Failed to parse LLM response as JSON", ) return GenerateReportResponse( success=True, section=request.section.value, data=data, ) if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000)