35분

Core: 제조 AI 통합 아키텍처 설계

시스템 아키텍처 설계

학습 목표

4-Layer 아키텍처 구조를 설명할 수 있다 RAG + Agent + KG 통합 데이터 흐름을 이해한다 컴포넌트 간 인터페이스를 정의할 수 있다

제조 AI 어시스턴트 4-Layer 아키텍처

┌─────────────────────────────────────────────────────────────────────┐
│                    Layer 1: Presentation (UI)                        │
│  ┌─────────────┐  ┌─────────────┐  ┌──────────┐  ┌──────────────┐  │
│  │ 채팅 인터페이스│  │ 문서 관리   │  │ KG 뷰어 │  │ 대시보드    │  │
│  │ (Streamlit) │  │ (업로드)    │  │ (시각화) │  │ (통계/로그)  │  │
│  └──────┬──────┘  └──────┬──────┘  └────┬─────┘  └──────┬───────┘  │
├─────────┼────────────────┼──────────────┼───────────────┼──────────┤
│         └────────────────┼──────────────┼───────────────┘          │
│                    Layer 2: Orchestration                            │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │                   LangGraph Agent Router                     │    │
│  │                                                             │    │
│  │   사용자 질문 분석 -> 도구 선택 -> 실행 -> 결과 종합         │    │
│  │                                                             │    │
│  │   ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌───────────┐  │    │
│  │   │ RAG Tool │  │ KG Tool  │  │ Calc Tool│  │ Alert Tool│  │    │
│  │   └──────────┘  └──────────┘  └──────────┘  └───────────┘  │    │
│  └─────────────────────────────────────────────────────────────┘    │
├─────────────────────────────────────────────────────────────────────┤
│                    Layer 3: Service (비즈니스 로직)                   │
│  ┌────────────────┐  ┌────────────────┐  ┌────────────────────┐    │
│  │  RAG Service   │  │  KG Service    │  │  LLM Service       │    │
│  │                │  │                │  │                    │    │
│  │ - 문서 임베딩  │  │ - Cypher 쿼리 │  │ - GPT-4o / Claude │    │
│  │ - 벡터 검색   │  │ - 관계 탐색    │  │ - Embedding 모델  │    │
│  │ - 컨텍스트 구성│  │ - 경로 분석    │  │ - 프롬프트 관리   │    │
│  └────────┬───────┘  └────────┬───────┘  └────────┬───────────┘    │
├───────────┼──────────────────┼──────────────────┼─────────────────┤
│           └──────────────────┼──────────────────┘                 │
│                    Layer 4: Data (데이터 저장)                       │
│  ┌────────────────┐  ┌────────────────┐  ┌────────────────────┐    │
│  │  ChromaDB      │  │  Neo4j         │  │  SQLite            │    │
│  │  (벡터 저장소) │  │  (그래프 DB)   │  │  (메타데이터/로그) │    │
│  └────────────────┘  └────────────────┘  └────────────────────┘    │
└─────────────────────────────────────────────────────────────────────┘

통합 데이터 흐름

유스케이스 1: 설비 트러블슈팅

사용자: "CNC-001 설비에서 알람 E-042가 발생했어. 어떻게 해야 해?"

Step 1: Agent가 질문 분석
  -> "설비 알람 문제 = RAG(매뉴얼) + KG(설비 관계) 필요"

Step 2: RAG Tool 호출
  -> ChromaDB에서 "CNC E-042 알람" 관련 매뉴얼 검색
  -> 결과: "E-042는 스핀들 과열 알람. 냉각수 확인 필요."

Step 3: KG Tool 호출
  -> Neo4j에서 CNC-001 관련 노드 탐색
  -> 결과: "CNC-001 -> 냉각시스템 CL-003 -> 냉각수펌프 CP-007"

Step 4: Agent가 결과 종합
  -> "E-042 알람은 스핀들 과열입니다.
      CNC-001의 냉각시스템 CL-003을 확인하세요.
      냉각수펌프 CP-007의 작동 상태를 점검하세요.
      매뉴얼 3.4.2절에 상세 절차가 있습니다."

유스케이스 2: 안전 규정 조회

사용자: "프레스 작업 시 안전 수칙 알려줘"

Step 1: Agent가 질문 분석
  -> "안전 규정 질문 = RAG만으로 충분"

Step 2: RAG Tool 호출
  -> ChromaDB에서 "프레스 안전 수칙" 검색
  -> KOSHA 안전지침, 사내 SOP 문서 반환

Step 3: LLM이 답변 생성
  -> 안전 수칙 정리하여 응답

유스케이스 3: 설비 관계 탐색

사용자: "CNC-001이 고장나면 영향받는 공정은?"

Step 1: Agent가 질문 분석
  -> "영향 분석 = KG 중심"

Step 2: KG Tool 호출
  -> MATCH (e:Equipment {id:'CNC-001'})-[:PART_OF]->(p:Process)
     RETURN p
  -> 결과: "가공 공정 (PR-002)"

Step 3: KG Tool 추가 호출
  -> "PR-002 이후 공정은?"
  -> 결과: "PR-002 -> PR-003(조립) -> PR-004(검사)"

Step 4: Agent 종합
  -> "CNC-001 고장 시 가공 공정(PR-002)이 중단됩니다.
      이후 조립(PR-003), 검사(PR-004)도 영향받습니다.
      대체 설비: CNC-002, CNC-005 (같은 라인)"

컴포넌트 인터페이스 정의

Service Layer 인터페이스

# 각 서비스의 공통 인터페이스 패턴

class RAGService:
    """벡터 검색 기반 문서 서비스"""
    def search(self, query: str, k: int = 5) -> list[Document]:
        """질문에 관련된 문서 검색"""
        ...

    def add_documents(self, files: list[UploadedFile]) -> int:
        """새 문서 추가 (임베딩 + 저장)"""
        ...

class KGService:
    """Knowledge Graph 서비스"""
    def query(self, cypher: str) -> list[dict]:
        """Cypher 쿼리 실행"""
        ...

    def find_related(self, entity_id: str, depth: int = 2) -> dict:
        """엔티티 관련 노드 탐색"""
        ...

    def get_impact(self, equipment_id: str) -> dict:
        """설비 영향도 분석"""
        ...

class LLMService:
    """LLM 호출 서비스"""
    def chat(self, messages: list[dict]) -> str:
        """대화 응답 생성"""
        ...

    def embed(self, texts: list[str]) -> list[list[float]]:
        """텍스트 임베딩"""
        ...

Orchestration Layer 인터페이스

class AgentOrchestrator:
    """LangGraph 기반 에이전트 오케스트레이터"""

    def __init__(self, rag: RAGService, kg: KGService, llm: LLMService):
        self.rag = rag
        self.kg = kg
        self.llm = llm
        self.graph = self._build_graph()

    def process(self, user_input: str, history: list = None) -> AgentResponse:
        """사용자 입력 처리 -> 도구 선택 -> 응답 생성"""
        ...

디렉토리 구조 (최종)

manufacturing-ai-assistant/
├── app/
│   ├── main.py                 # Streamlit 진입점
│   ├── pages/
│   │   ├── 1_Chat.py           # 채팅 페이지
│   │   ├── 2_Documents.py      # 문서 관리
│   │   ├── 3_KnowledgeGraph.py # KG 시각화
│   │   └── 4_Dashboard.py      # 대시보드
│   └── components/
│       ├── chat_ui.py          # 채팅 UI 컴포넌트
│       └── kg_viewer.py        # KG 시각화 컴포넌트
│
├── core/
│   ├── __init__.py
│   ├── agent/
│   │   ├── __init__.py
│   │   ├── graph.py            # LangGraph 정의
│   │   ├── nodes.py            # 에이전트 노드
│   │   ├── state.py            # 에이전트 상태
│   │   └── tools.py            # 도구 정의
│   ├── rag/
│   │   ├── __init__.py
│   │   ├── embeddings.py       # 임베딩 서비스
│   │   ├── retriever.py        # 검색기
│   │   └── loader.py           # 문서 로더
│   ├── kg/
│   │   ├── __init__.py
│   │   ├── client.py           # Neo4j 클라이언트
│   │   └── queries.py          # Cypher 쿼리 모음
│   └── llm/
│       ├── __init__.py
│       └── provider.py         # LLM 프로바이더
│
├── config/
│   ├── settings.py             # 환경 설정
│   └── prompts.py              # 프롬프트 템플릿
│
├── data/
│   ├── documents/              # 제조 매뉴얼 (PDF, TXT)
│   ├── sample/                 # 샘플 데이터
│   └── chroma_db/              # 벡터 DB 저장소
│
├── tests/
│   ├── test_rag.py
│   ├── test_kg.py
│   └── test_agent.py
│
├── .env.example
├── docker compose.yml
├── Dockerfile
├── pyproject.toml
└── README.md

핵심 원칙:

  • core/: 비즈니스 로직 (UI 무관)
  • app/: UI 코드 (core를 import)
  • config/: 설정 집중 관리
  • data/: 데이터 파일 격리
AI로 학습하기 — 꿀팁
🧪4-Layer 아키텍처 제조 적용AI 학습 팁

RAG+Agent+KG 통합 4-Layer 구조를 실제 제조 공정에 매핑하는 예시를 AI에게 요청해 개념을 구체화하세요.

제조 AI 통합 4-Layer 아키텍처(데이터 레이어→지식 레이어→에이전트 레이어→인터페이스 레이어)를 자동차 엔진 조립라인에 적용할 때, 각 레이어에 어떤 컴포넌트가 들어가고 레이어 간 데이터 흐름이 어떻게 되는지 구체적인 다이어그램 설명 형식으로 알려줘.
이 팁이 도움이 됐나요?
핵심 포인트
  • • 4-Layer: Presentation -> Orchestration -> Service -> Data
  • • Agent가 RAG와 KG를 도구(Tool)로 사용
  • • 각 서비스는 독립적 인터페이스를 가짐
  • • MVP는 모놀리식 구조가 최적
이전다음
이 콘텐츠에 오류가 있나요? 신고하기