Week 9. 서비스 아키텍처 및 성능 최적화

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   Frontend  │────▶│   FastAPI   │────▶│   Neo4j     │
│  (React)    │     │   Server    │     │   Graph DB  │
└─────────────┘     └─────────────┘     └─────────────┘
      │                    │                    │
      │             ┌──────┴──────┐            │
      │             ▼             ▼            │
      │      ┌──────────┐  ┌──────────┐       │
      └─────▶│  D3.js   │  │   LLM    │◀──────┘
             │  Viz     │  │  Service │
             └──────────┘  └──────────┘

import NeoVis from 'neovis.js';
 
const config = {
    containerId: "viz",
    neo4j: {
        serverUrl: "bolt://localhost:7687",
        serverUser: "neo4j",
        serverPassword: "password",
    },
    labels: {
        Movie: { label: "title", size: "popularity" },
        Person: { label: "name" }
    },
    relationships: {
        DIRECTED: { thickness: "weight" },
        ACTED_IN: { thickness: "weight" }
    },
    initialCypher: `
        MATCH (d:Director)-[:DIRECTED]->(m:Movie)<-[:ACTED_IN]-(a:Actor)
        RETURN d, m, a LIMIT 100
    `
};
 
const viz = new NeoVis(config);
viz.render();

from pyvis.network import Network
 
def visualize_graph(neo4j_driver, query):
    net = Network(height="600px", width="100%", notebook=True)
 
    with neo4j_driver.session() as session:
        result = session.run(query)
        for record in result:
            for node in record["nodes"]:
                net.add_node(node.id, label=node["name"])
            for rel in record["rels"]:
                net.add_edge(rel.start_node.id, rel.end_node.id, title=rel.type)
 
    return net.show("graph.html")

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from neo4j import GraphDatabase
 
app = FastAPI(title="Knowledge Graph API")
 
class QueryRequest(BaseModel):
    query: str
    params: dict = {}
 
class EntityRequest(BaseModel):
    name: str
    entity_type: str
    properties: dict = {}
 
@app.post("/query")
async def execute_query(request: QueryRequest):
    with driver.session() as session:
        result = session.run(request.query, request.params)
        return [dict(record) for record in result]
 
@app.get("/entity/{entity_type}/{name}")
async def get_entity(entity_type: str, name: str):
    query = f"""
        MATCH (e:{entity_type} {{name: $name}})
        OPTIONAL MATCH (e)-[r]-(connected)
        RETURN e, collect({{rel: type(r), node: connected}}) as connections
    """
    with driver.session() as session:
        result = session.run(query, name=name)
        record = result.single()
        if not record:
            raise HTTPException(404, "Entity not found")
        return dict(record)
 
@app.post("/entity")
async def create_entity(request: EntityRequest):
    query = f"""
        CREATE (e:{request.entity_type} {{name: $name}})
        SET e += $properties
        RETURN e
    """
    with driver.session() as session:
        result = session.run(query, name=request.name, properties=request.properties)
        return dict(result.single()["e"])

class GraphUpdater:
    def __init__(self, driver):
        self.driver = driver
 
    def upsert_entity(self, entity_type, entity_id, properties):
        """개체 업서트 (있으면 업데이트, 없으면 생성)"""
        query = f"""
            MERGE (e:{entity_type} {{id: $id}})
            SET e += $properties
            SET e.updated_at = datetime()
            RETURN e
        """
        with self.driver.session() as session:
            return session.run(query, id=entity_id, properties=properties).single()
 
    def add_relationship(self, source_id, target_id, rel_type, properties=None):
        """관계 추가 (중복 방지)"""
        query = """
            MATCH (s {id: $source_id})
            MATCH (t {id: $target_id})
            MERGE (s)-[r:$rel_type]->(t)
            SET r += $properties
            RETURN r
        """
        with self.driver.session() as session:
            return session.run(query,
                source_id=source_id,
                target_id=target_id,
                rel_type=rel_type,
                properties=properties or {}
            ).single()
 
    def sync_from_source(self, source_data, last_sync_time):
        """외부 소스와 동기화"""
        new_records = [r for r in source_data if r["updated_at"] > last_sync_time]
        for record in new_records:
            self.upsert_entity(
                record["type"],
                record["id"],
                record["properties"]
            )

// 조회 성능 향상
CREATE INDEX entity_id FOR (n:Entity) ON (n.id)
CREATE INDEX entity_name FOR (n:Entity) ON (n.name)
 
// 복합 인덱스
CREATE INDEX movie_year_title FOR (m:Movie) ON (m.year, m.title)
 
// 전문 검색
CREATE FULLTEXT INDEX entity_search FOR (n:Entity) ON EACH [n.name, n.description]

// Bad: 전체 스캔
MATCH (m:Movie) WHERE m.title CONTAINS "Inception" RETURN m
 
// Good: 인덱스 활용
MATCH (m:Movie) WHERE m.title = "Inception" RETURN m
 
// Better: 파라미터 사용 (캐싱)
MATCH (m:Movie {title: $title}) RETURN m

┌─────────────────────────────────────────────┐
│                   Frontend                   │
│  (React Dashboard + Chat Interface)          │
└─────────────────┬───────────────────────────┘
                  │ REST API
┌─────────────────▼───────────────────────────┐
│                FastAPI Server                │
│  /recommend  /search  /chat  /update        │
└──────┬──────────────┬───────────────────────┘
       │              │
┌──────▼──────┐ ┌─────▼─────┐
│   Neo4j     │ │   LLM     │
│ (Graph DB)  │ │ (OpenAI)  │
└─────────────┘ └───────────┘

@app.get("/recommend/{movie_title}")
# 유사 영화 추천
 
@app.post("/chat")
# 자연어 질의 (GraphRAG)
 
@app.post("/update")
# 새 영화 추가 (에이전트 트리거)
 
@app.get("/graph/stats")
# 지식그래프 통계