analytics_app.py

"""
FastAPI Application for Intelligence Knowledge Graph Analytics

Standalone app for testing analytics endpoints.
In production, integrate this into your main backend/api/main.py

Author: Federico Chiaradia
Date: 2025-12-12
"""

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from neo4j import GraphDatabase
from contextlib import asynccontextmanager
import logging

from backend.api.analytics_api import router as analytics_router, initialize_analytics, _analytics

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

# Neo4j connection settings
NEO4J_URI = "bolt://localhost:7687"
NEO4J_USER = "neo4j"
NEO4J_PASSWORD = "password123"  # Update if you changed it

# Global Neo4j driver
driver = None


@asynccontextmanager
async def lifespan(app: FastAPI):
    """
    Lifespan context manager for startup and shutdown events.
    Handles Neo4j connection lifecycle.
    """
    global driver
    
    # Startup
    logger.info("Starting Intelligence Knowledge Graph API...")
    
    try:
        # Connect to Neo4j
        driver = GraphDatabase.driver(NEO4J_URI, auth=(NEO4J_USER, NEO4J_PASSWORD))
        
        # Verify connection
        with driver.session() as session:
            result = session.run("RETURN 1")
            result.single()
        
        logger.info(f" Connected to Neo4j at {NEO4J_URI}")
        
        # Initialize analytics service
        initialize_analytics(driver)
        logger.info(" Analytics service initialized")
        
        # Load graph from Neo4j (eager loading for better UX)
        import backend.api.analytics_api as an_ap
        logger.info(" Loading graph from Neo4j...")
        an_ap._analytics.load_graph_from_neo4j()
        node_count = an_ap._analytics.graph.number_of_nodes()
        edge_count = an_ap._analytics.graph.number_of_edges()
        logger.info(f" Graph loaded: {node_count} nodes, {edge_count} edges")
		
    except Exception as e:
        logger.error(f" Failed to initialize: {e}")
        raise
    
    yield
    
    # Shutdown
    logger.info("Shutting down...")
    if driver:
        driver.close()
        logger.info(" Neo4j connection closed")


# Create FastAPI app
app = FastAPI(
    title="Intelligence Knowledge Graph - Analytics API",
    description="""
Advanced graph analytics for intelligence knowledge graphs.

## Features

- **PageRank Centrality** - Identify most important entities
- **Community Detection** - Discover network clusters using Louvain algorithm
- **Network Metrics** - Global graph statistics and health indicators
- **Node Analysis** - Detailed importance analysis for specific entities
- **Key Connectors** - Find bridge nodes that connect different clusters

## Authentication

Currently no authentication required (development mode).
Add API keys or OAuth for production deployment.

## Rate Limiting

Not implemented. Consider adding for production:

- 100 requests/minute per IP
- 1000 requests/hour per user

## Contact

- **Author**: Federico Chiaradia
- **GitHub**: [https://github.com/Fredbcx](https://github.com/Fredbcx)
- **LinkedIn**: [LinkedIn Profile](https://www.linkedin.com/in/federico-chiaradia-b6b814164/)
""",
    version="1.0.0",
    lifespan=lifespan,
    docs_url="/docs",
    redoc_url="/redoc"
)

# CORS middleware (for frontend development)
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # In production: specify exact origins
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Include analytics router
app.include_router(analytics_router)


@app.get("/", tags=["Root"])
async def root():
    """
    Root endpoint - API information and available routes.
    """
    return {
        "name": "Intelligence Knowledge Graph - Analytics API",
        "version": "1.0.0",
        "status": "operational",
        "documentation": "/docs",
        "endpoints": {
            "health": "/analytics/health",
            "pagerank": "/analytics/pagerank",
            "communities": "/analytics/communities",
            "metrics": "/analytics/metrics",
            "node_importance": "/analytics/node/{node_id}/importance",
            "connectors": "/analytics/connectors",
            "refresh": "/analytics/refresh (POST)"
        },
        "author": "Federico Chiaradia"
	}


@app.get("/health", tags=["Root"])
async def health():
    """
    Simple health check for load balancers.
    For detailed analytics health, use /analytics/health
    """
    return {
        "status": "healthy",
        "service": "analytics-api"
    }


if __name__ == "__main__":
    import uvicorn
    
    print("=" * 70)
    print("INTELLIGENCE KNOWLEDGE GRAPH - ANALYTICS API")
    print("=" * 70)
    print(f"Starting server...")
    print(f"API Documentation: http://localhost:8000/docs")
    print(f"Alternative Docs: http://localhost:8000/redoc")
    print("=" * 70)
    
    uvicorn.run(
        "analytics_app:app",
        host="0.0.0.0",
        port=8000,
        reload=True,  # Auto-reload on code changes
        log_level="info"
    )