Refactor/api

src/agents/__init__.py

@@ -0,0 +1,6 @@
+"""
+에이전트 루트 패키지
+"""
+
+
+

src/agents/sql_agent/__init__.py

@@ -0,0 +1,27 @@
+# src/agents/sql_agent/__init__.py
+
+from .state import SqlAgentState
+from .nodes import SqlAgentNodes
+from .edges import SqlAgentEdges
+from .graph import SqlAgentGraph
+from .exceptions import (
+    SqlAgentException,
+    ValidationException,
+    ExecutionException,
+    DatabaseConnectionException,
+    LLMProviderException,
+    MaxRetryExceededException
+)
+
+__all__ = [
+    'SqlAgentState',
+    'SqlAgentNodes',
+    'SqlAgentEdges', 
+    'SqlAgentGraph',
+    'SqlAgentException',
+    'ValidationException',
+    'ExecutionException',
+    'DatabaseConnectionException',
+    'LLMProviderException',
+    'MaxRetryExceededException'
+]

src/agents/sql_agent/edges.py

@@ -0,0 +1,51 @@
+# src/agents/sql_agent/edges.py
+
+from .state import SqlAgentState
+
+# 상수 정의
+MAX_ERROR_COUNT = 3
+
+class SqlAgentEdges:
+    """SQL Agent의 모든 엣지 로직을 담당하는 클래스"""
+
+    @staticmethod
+    def route_after_intent_classification(state: SqlAgentState) -> str:
+        """의도 분류 결과에 따라 라우팅을 결정합니다."""
+        if state['intent'] == "SQL":
+            print("--- 의도: SQL 관련 질문 ---")
+            return "db_classifier"
+        print("--- 의도: SQL과 관련 없는 질문 ---")
+        return "unsupported_question"
+
+    @staticmethod
+    def should_execute_sql(state: SqlAgentState) -> str:
+        """SQL 검증 결과에 따라 다음 단계를 결정합니다."""
+        validation_error_count = state.get("validation_error_count", 0)
+
+        if validation_error_count >= MAX_ERROR_COUNT:
+            print(f"--- 검증 실패 {MAX_ERROR_COUNT}회 초과: 답변 생성으로 이동 ---")
+            return "synthesize_failure"
+
+        if state.get("validation_error"):
+            print(f"--- 검증 실패 {validation_error_count}회: SQL 재생성 ---")
+            return "regenerate"
+
+        print("--- 검증 성공: SQL 실행 ---")
+        return "execute"
+
+    @staticmethod
+    def should_retry_or_respond(state: SqlAgentState) -> str:
+        """SQL 실행 결과에 따라 다음 단계를 결정합니다."""
+        execution_error_count = state.get("execution_error_count", 0)
+        execution_result = state.get("execution_result", "")
+
+        if execution_error_count >= MAX_ERROR_COUNT:
+            print(f"--- 실행 실패 {MAX_ERROR_COUNT}회 초과: 답변 생성으로 이동 ---")
+            return "synthesize_failure"
+
+        if "오류" in execution_result:
+            print(f"--- 실행 실패 {execution_error_count}회: SQL 재생성 ---")
+            return "regenerate"
+
+        print("--- 실행 성공: 최종 답변 생성 ---")
+        return "synthesize_success"

src/agents/sql_agent/exceptions.py

@@ -0,0 +1,31 @@
+# src/agents/sql_agent/exceptions.py
+
+class SqlAgentException(Exception):
+    """SQL Agent 관련 기본 예외 클래스"""
+    pass
+
+class ValidationException(SqlAgentException):
+    """SQL 검증 실패 예외"""
+    def __init__(self, message: str, error_count: int = 0):
+        super().__init__(message)
+        self.error_count = error_count
+
+class ExecutionException(SqlAgentException):
+    """SQL 실행 실패 예외"""
+    def __init__(self, message: str, error_count: int = 0):
+        super().__init__(message)
+        self.error_count = error_count
+
+class DatabaseConnectionException(SqlAgentException):
+    """데이터베이스 연결 실패 예외"""
+    pass
+
+class LLMProviderException(SqlAgentException):
+    """LLM 제공자 관련 예외"""
+    pass
+
+class MaxRetryExceededException(SqlAgentException):
+    """최대 재시도 횟수 초과 예외"""
+    def __init__(self, message: str, max_retries: int):
+        super().__init__(f"{message} (최대 재시도 {max_retries}회 초과)")
+        self.max_retries = max_retries

src/agents/sql_agent/graph.py

@@ -0,0 +1,129 @@
+# src/agents/sql_agent/graph.py
+
+from langgraph.graph import StateGraph, END
+from core.providers.llm_provider import LLMProvider
+from services.database.database_service import DatabaseService
+from .state import SqlAgentState
+from .nodes import SqlAgentNodes
+from .edges import SqlAgentEdges
+
+class SqlAgentGraph:
+    """SQL Agent 그래프를 구성하고 관리하는 클래스"""
+
+    def __init__(self, llm_provider: LLMProvider, database_service: DatabaseService):
+        self.llm_provider = llm_provider
+        self.database_service = database_service
+        self.nodes = SqlAgentNodes(llm_provider, database_service)
+        self.edges = SqlAgentEdges()
+        self._graph = None
+
+    def create_graph(self) -> StateGraph:
+        """SQL Agent 그래프를 생성하고 구성합니다."""
+        if self._graph is not None:
+            return self._graph
+
+        graph = StateGraph(SqlAgentState)
+
+        # 노드 추가
+        self._add_nodes(graph)
+
+        # 엣지 추가
+        self._add_edges(graph)
+
+        # 진입점 설정
+        graph.set_entry_point("intent_classifier")
+
+        # 그래프 컴파일
+        self._graph = graph.compile()
+        return self._graph
+
+    def _add_nodes(self, graph: StateGraph):
+        """그래프에 모든 노드를 추가합니다."""
+        graph.add_node("intent_classifier", self.nodes.intent_classifier_node)
+        graph.add_node("db_classifier", self.nodes.db_classifier_node)
+        graph.add_node("unsupported_question", self.nodes.unsupported_question_node)
+        graph.add_node("sql_generator", self.nodes.sql_generator_node)
+        graph.add_node("sql_validator", self.nodes.sql_validator_node)
+        graph.add_node("sql_executor", self.nodes.sql_executor_node)
+        graph.add_node("response_synthesizer", self.nodes.response_synthesizer_node)
+
+    def _add_edges(self, graph: StateGraph):
+        """그래프에 모든 엣지를 추가합니다."""
+        # 의도 분류 후 조건부 라우팅
+        graph.add_conditional_edges(
+            "intent_classifier",
+            self.edges.route_after_intent_classification,
+            {
+                "db_classifier": "db_classifier",
+                "unsupported_question": "unsupported_question"
+            }
+        )
+
+        # 지원되지 않는 질문 처리 후 종료
+        graph.add_edge("unsupported_question", END)
+
+        # DB 분류 후 SQL 생성으로 이동
+        graph.add_edge("db_classifier", "sql_generator")
+
+        # SQL 생성 후 검증으로 이동
+        graph.add_edge("sql_generator", "sql_validator")
+
+        # SQL 검증 후 조건부 라우팅
+        graph.add_conditional_edges(
+            "sql_validator", 
+            self.edges.should_execute_sql, 
+            {
+                "regenerate": "sql_generator",
+                "execute": "sql_executor",
+                "synthesize_failure": "response_synthesizer"
+            }
+        )
+
+        # SQL 실행 후 조건부 라우팅
+        graph.add_conditional_edges(
+            "sql_executor", 
+            self.edges.should_retry_or_respond, 
+            {
+                "regenerate": "sql_generator",
+                "synthesize_success": "response_synthesizer",
+                "synthesize_failure": "response_synthesizer"
+            }
+        )
+
+        # 응답 생성 후 종료
+        graph.add_edge("response_synthesizer", END)
+
+    async def run(self, initial_state: dict) -> dict:
+        """그래프를 실행하고 결과를 반환합니다."""
+        try:
+            if self._graph is None:
+                self.create_graph()
+
+            result = await self._graph.ainvoke(initial_state)
+            return result
+
+        except Exception as e:
+            print(f"그래프 실행 중 오류 발생: {e}")
+            # 에러 발생 시 예외를 다시 발생시켜 상위 레벨에서 HTTP 에러로 처리되도록 함
+            raise e
+
+    def save_graph_visualization(self, file_path: str = "sql_agent_graph.png") -> bool:
+        """그래프 시각화를 파일로 저장합니다."""
+        try:
+            if self._graph is None:
+                self.create_graph()
+
+            # PNG 이미지 생성
+            png_data = self._graph.get_graph(xray=True).draw_mermaid_png()
+
+            # 파일로 저장
+            with open(file_path, "wb") as f:
+                f.write(png_data)
+
+            print(f"그래프 시각화가 {file_path}에 저장되었습니다.")
+            return True
+
+        except Exception as e:
+            print(f"그래프 시각화 저장 실패: {e}")
+            return False
+