Devcafe: 새 문서: == Palantir Ontology 기반 CRUD 자동 생성 시스템 설계 == === Ontology 개념 적용 개요 === Palantir의 Ontology는 데이터를 Objects(객체), Properties(속성), Links(관계)로 모델링하여 비즈니스 도메인을 표현합니다. 이를 적용하여 단순 테이블 기반 CRUD를 넘어 의미론적 데이터 관리 시스템으로 진화시킵니다. ### 핵심 개선 사항 - Object Types: 테이블을 비즈니스 객체로...

2025-12-15T05:53:39Z

새 문서: == Palantir Ontology 기반 CRUD 자동 생성 시스템 설계 == === Ontology 개념 적용 개요 === Palantir의 Ontology는 데이터를 **Objects(객체)**, **Properties(속성)**, **Links(관계)**로 모델링하여 비즈니스 도메인을 표현합니다. 이를 적용하여 단순 테이블 기반 CRUD를 넘어 **의미론적 데이터 관리 시스템**으로 진화시킵니다. ### 핵심 개선 사항 - **Object Types**: 테이블을 비즈니스 객체로...

새 문서

== Palantir Ontology 기반 CRUD 자동 생성 시스템 설계 ==

=== Ontology 개념 적용 개요 ===

Palantir의 Ontology는 데이터를 **Objects(객체)**, **Properties(속성)**, **Links(관계)**로 모델링하여 비즈니스 도메인을 표현합니다. 이를 적용하여 단순 테이블 기반 CRUD를 넘어 **의미론적 데이터 관리 시스템**으로 진화시킵니다.

### 핵심 개선 사항

- **Object Types**: 테이블을 비즈니스 객체로 추상화
- **Property Types**: 컬럼을 타입화된 속성으로 정의
- **Link Types**: 테이블 간 관계를 명시적 링크로 표현
- **Actions**: CRUD를 넘어 비즈니스 액션 정의
- **Pipelines**: 데이터 변환 및 통합 파이프라인

=== 개선된 기술 스택 ===

### 백엔드

- **언어**: Python 3.10+
- **웹 프레임워크**: FastAPI 0.104 (비동기 처리, 자동 API 문서)
- **데이터베이스**: SQLite (기본), PostgreSQL, Oracle
- **Graph DB**: Neo4j 5.x (관계 저장 및 탐색)
- **ORM**: SQLAlchemy 2.0 + Neomodel (Graph ORM)
- **검색 엔진**: Elasticsearch 8.x (온톨로지 검색)

### 프론트엔드

- **프레임워크**: React 18 + TypeScript
- **UI 라이브러리**: shadcn/ui, Material-UI
- **그래프 시각화**: D3.js, Cytoscape.js
- **상태 관리**: Zustand
- **폼 관리**: React Hook Form + Zod

=== 필요한 Python 패키지 ===

```txt
# 웹 프레임워크
fastapi==0.104.1
uvicorn[standard]==0.24.0
pydantic==2.5.0
pydantic-settings==2.1.0

# 데이터베이스
sqlalchemy==2.0.23
alembic==1.12.1
oracledb==2.0.0
psycopg2-binary==2.9.9

# Graph Database
neo4j==5.14.0
neomodel==5.2.1

# 검색
elasticsearch==8.11.0

# 데이터 처리
pandas==2.1.3
networkx==3.2.1

# 파일 처리
python-multipart==0.0.6
aiofiles==23.2.1
Pillow==10.1.0

# 유틸리티
python-dotenv==1.0.0
PyYAML==6.0.1
pydantic-core==2.14.5

# API 문서
fastapi-users==12.1.2
```

=== 개선된 프로젝트 구조 ===

```
ontology_crud_system/
│
├── main.py # FastAPI 애플리케이션 진입점
├── config.py # 설정 관리
├── requirements.txt
├── .env
├── README.md
│
├── alembic/ # DB 마이그레이션
│ └── versions/
│
├── app/
│ ├── __init__.py
│ │
│ ├── ontology/ # 온톨로지 핵심 모듈
│ │ ├── __init__.py
│ │ │
│ │ ├── models/ # 온톨로지 모델
│ │ │ ├── __init__.py
│ │ │ ├── object_type.py # 객체 타입 정의
│ │ │ ├── property_type.py # 속성 타입 정의
│ │ │ ├── link_type.py # 링크 타입 정의
│ │ │ ├── action_type.py # 액션 타입 정의
│ │ │ └── pipeline.py # 데이터 파이프라인
│ │ │
│ │ ├── registry/ # 온톨로지 레지스트리
│ │ │ ├── __init__.py
│ │ │ ├── object_registry.py # 객체 타입 등록/관리
│ │ │ ├── property_registry.py
│ │ │ ├── link_registry.py
│ │ │ └── action_registry.py
│ │ │
│ │ ├── engine/ # 온톨로지 엔진
│ │ │ ├── __init__.py
│ │ │ ├── inference_engine.py # 추론 엔진
│ │ │ ├── validation_engine.py # 검증 엔진
│ │ │ ├── query_engine.py # 온톨로지 쿼리
│ │ │ └── graph_engine.py # 그래프 탐색
│ │ │
│ │ └── schema/ # 온톨로지 스키마
│ │ ├── __init__.py
│ │ ├── schema_builder.py # 스키마 빌더
│ │ ├── schema_validator.py # 스키마 검증
│ │ └── schema_evolution.py # 스키마 버전 관리
│ │
│ ├── models/ # 데이터 모델
│ │ ├── __init__.py
│ │ │
│ │ ├── relational/ # 관계형 DB 모델
│ │ │ ├── __init__.py
│ │ │ ├── base.py
│ │ │ ├── ontology_metadata.py # 온톨로지 메타데이터
│ │ │ ├── object_instance.py # 객체 인스턴스
│ │ │ ├── property_value.py # 속성 값
│ │ │ └── attachment.py
│ │ │
│ │ └── graph/ # 그래프 DB 모델
│ │ ├── __init__.py
│ │ ├── object_node.py # 객체 노드
│ │ ├── link_relationship.py # 링크 관계
│ │ └── property_edge.py # 속성 엣지
│ │
│ ├── core/ # 핵심 비즈니스 로직
│ │ ├── __init__.py
│ │ │
│ │ ├── discovery/ # 자동 발견
│ │ │ ├── __init__.py
│ │ │ ├── schema_scanner.py # 스키마 스캔
│ │ │ ├── relationship_detector.py # 관계 감지
│ │ │ └── ontology_mapper.py # 온톨로지 매핑
│ │ │
│ │ ├── generator/ # 코드 생성
│ │ │ ├── __init__.py
│ │ │ ├── object_crud_gen.py # 객체 CRUD 생성
│ │ │ ├── link_crud_gen.py # 링크 CRUD 생성
│ │ │ ├── action_gen.py # 액션 생성
│ │ │ └── ui_component_gen.py # UI 컴포넌트 생성
│ │ │
│ │ ├── transformation/ # 데이터 변환
│ │ │ ├── __init__.py
│ │ │ ├── pipeline_executor.py
│ │ │ ├── etl_engine.py
│ │ │ └── data_mapper.py
│ │ │
│ │ └── intelligence/ # 지능형 기능
│ │ ├── __init__.py
│ │ ├── auto_linker.py # 자동 링크 생성
│ │ ├── property_suggester.py # 속성 제안
│ │ └── anomaly_detector.py # 이상 탐지
│ │
│ ├── api/ # API 엔드포인트
│ │ ├── __init__.py
│ │ │
│ │ ├── v1/
│ │ │ ├── __init__.py
│ │ │ ├── objects.py # 객체 API
│ │ │ ├── properties.py # 속성 API
│ │ │ ├── links.py # 링크 API
│ │ │ ├── actions.py # 액션 API
│ │ │ ├── search.py # 검색 API
│ │ │ ├── graph.py # 그래프 탐색 API
│ │ │ └── ontology.py # 온톨로지 관리 API
│ │ │
│ │ └── websocket/ # WebSocket
│ │ ├── __init__.py
│ │ └── realtime_updates.py # 실시간 업데이트
│ │
│ ├── services/ # 비즈니스 서비스
│ │ ├── __init__.py
│ │ ├── object_service.py # 객체 관리
│ │ ├── link_service.py # 링크 관리
│ │ ├── action_service.py # 액션 실행
│ │ ├── search_service.py # 검색 서비스
│ │ ├── graph_service.py # 그래프 서비스
│ │ └── pipeline_service.py # 파이프라인 서비스
│ │
│ ├── repositories/ # 데이터 접근 계층
│ │ ├── __init__.py
│ │ ├── relational_repo.py # 관계형 DB 리포지토리
│ │ ├── graph_repo.py # 그래프 DB 리포지토리
│ │ └── search_repo.py # 검색 리포지토리
│ │
│ ├── schemas/ # Pydantic 스키마
│ │ ├── __init__.py
│ │ ├── object_schema.py
│ │ ├── property_schema.py
│ │ ├── link_schema.py
│ │ ├── action_schema.py
│ │ └── response_schema.py
│ │
│ └── utils/ # 유틸리티
│ ├── __init__.py
│ ├── validators.py
│ ├── type_converters.py
│ ├── graph_utils.py
│ └── logger.py
│
├── frontend/ # React 프론트엔드
│ ├── package.json
│ ├── tsconfig.json
│ │
│ ├── src/
│ │ ├── App.tsx
│ │ ├── main.tsx
│ │ │
│ │ ├── features/ # 기능별 모듈
│ │ │ ├── ontology/
│ │ │ │ ├── components/ # 온톨로지 관리 컴포넌트
│ │ │ │ │ ├── ObjectTypeEditor.tsx
│ │ │ │ │ ├── PropertyTypeEditor.tsx
│ │ │ │ │ ├── LinkTypeEditor.tsx
│ │ │ │ │ └── OntologyViewer.tsx
│ │ │ │ └── hooks/
│ │ │ │ └── useOntology.ts
│ │ │ │
│ │ │ ├── objects/ # 객체 관리
│ │ │ │ ├── components/
│ │ │ │ │ ├── ObjectList.tsx
│ │ │ │ │ ├── ObjectDetail.tsx
│ │ │ │ │ ├── ObjectForm.tsx
│ │ │ │ │ └── ObjectGraph.tsx
│ │ │ │ └── hooks/
│ │ │ │ └── useObjects.ts
│ │ │ │
│ │ │ ├── links/ # 링크 관리
│ │ │ │ ├── components/
│ │ │ │ │ ├── LinkExplorer.tsx
│ │ │ │ │ ├── LinkCreator.tsx
│ │ │ │ │ └── NetworkGraph.tsx
│ │ │ │ └── hooks/
│ │ │ │ └── useLinks.ts
│ │ │ │
│ │ │ ├── actions/ # 액션 실행
│ │ │ │ ├── components/
│ │ │ │ │ ├── ActionPanel.tsx
│ │ │ │ │ ├── ActionForm.tsx
│ │ │ │ │ └── ActionHistory.tsx
│ │ │ │ └── hooks/
│ │ │ │ └── useActions.ts
│ │ │ │
│ │ │ └── search/ # 검색
│ │ │ ├── components/
│ │ │ │ ├── OntologySearch.tsx
│ │ │ │ ├── SearchFilters.tsx
│ │ │ │ └── SearchResults.tsx
│ │ │ └── hooks/
│ │ │ └── useSearch.ts
│ │ │
│ │ ├── components/ # 공통 컴포넌트
│ │ │ ├── ui/ # shadcn/ui 컴포넌트
│ │ │ ├── layout/
│ │ │ │ ├── Header.tsx
│ │ │ │ ├── Sidebar.tsx
│ │ │ │ ├── Navigation.tsx
│ │ │ │ └── Footer.tsx
│ │ │ ├── graph/
│ │ │ │ ├── GraphVisualization.tsx
│ │ │ │ └── GraphControls.tsx
│ │ │ └── forms/
│ │ │ ├── DynamicForm.tsx
│ │ │ └── FileUpload.tsx
│ │ │
│ │ ├── stores/ # Zustand 스토어
│ │ │ ├── ontologyStore.ts
│ │ │ ├── objectStore.ts
│ │ │ ├── linkStore.ts
│ │ │ └── themeStore.ts
│ │ │
│ │ ├── services/ # API 서비스
│ │ │ ├── api.ts
│ │ │ ├── ontologyApi.ts
│ │ │ ├── objectApi.ts
│ │ │ └── linkApi.ts
│ │ │
│ │ ├── types/ # TypeScript 타입
│ │ │ ├── ontology.ts
│ │ │ ├── object.ts
│ │ │ └── link.ts
│ │ │
│ │ └── utils/
│ │ ├── graphUtils.ts
│ │ └── validators.ts
│ │
│ └── public/
│
└── tests/
├── unit/
├── integration/
└── e2e/
```

=== 온톨로지 데이터 모델 ===

==== Object Types (객체 타입) ====

```
ontology_object_types
- id: UUID PRIMARY KEY
- type_name: VARCHAR(100) UNIQUE (예: Employee, Department, Project)
- display_name: VARCHAR(200)
- description: TEXT
- icon: VARCHAR(50)
- color: VARCHAR(20)
- base_table: VARCHAR(100) (원본 테이블명)
- is_abstract: BOOLEAN (추상 타입 여부)
- parent_type_id: UUID FK (상속 관계)
- metadata: JSONB (추가 메타데이터)
- created_at: TIMESTAMP
- updated_at: TIMESTAMP
```

==== Property Types (속성 타입) ====

```
ontology_property_types
- id: UUID PRIMARY KEY
- property_name: VARCHAR(100)
- display_name: VARCHAR(200)
- description: TEXT
- data_type: VARCHAR(50) (String, Number, Date, Boolean, File, Reference)
- base_type: VARCHAR(50) (원본 SQL 타입)
- object_type_id: UUID FK
- is_required: BOOLEAN
- is_unique: BOOLEAN
- is_indexed: BOOLEAN
- default_value: TEXT
- validation_rules: JSONB
{
"min_length": 5,
"max_length": 100,
"pattern": "^[A-Z].*",
"min_value": 0,
"max_value": 100,
"allowed_values": ["A", "B", "C"]
}
- format_options: JSONB
{
"date_format": "YYYY-MM-DD",
"number_format": "#,##0.00",
"currency": "KRW"
}
- ui_config: JSONB
{
"input_type": "text/number/date/select/file",
"placeholder": "Enter value...",
"help_text": "Description"
}
- created_at: TIMESTAMP
```

==== Link Types (링크 타입) ====

```
ontology_link_types
- id: UUID PRIMARY KEY
- link_name: VARCHAR(100) (예: WorksFor, BelongsTo, Manages)
- display_name: VARCHAR(200)
- description: TEXT
- source_object_type_id: UUID FK
- target_object_type_id: UUID FK
- cardinality: VARCHAR(20) (ONE_TO_ONE, ONE_TO_MANY, MANY_TO_MANY)
- is_bidirectional: BOOLEAN
- reverse_link_name: VARCHAR(100)
- base_constraint: VARCHAR(200) (FK 제약조건명)
- link_properties: JSONB (링크 자체의 속성)
{
"start_date": "date",
"end_date": "date",
"role": "string"
}
- created_at: TIMESTAMP
```

====Link Instances (링크 인스턴스)====

```
ontology_link_instances
- id: UUID PRIMARY KEY
- link_type_id: UUID FK
- source_object_id: UUID FK
- target_object_id: UUID FK
- properties: JSONB (링크 속성 값)
- created_at: TIMESTAMP
- created_by: VARCHAR(100)
```

==== Action Types (액션 타입) ====

```
ontology_action_types
- id: UUID PRIMARY KEY
- action_name: VARCHAR(100) (예: Approve, Reject, Transfer)
- display_name: VARCHAR(200)
- description: TEXT
- object_type_id: UUID FK (적용 대상 객체)
- action_category: VARCHAR(50) (CREATE, UPDATE, DELETE, CUSTOM)
- icon: VARCHAR(50)
- color: VARCHAR(20)
- parameters: JSONB
[
{
"name": "approval_comment",
"type": "string",
"required": true
}
]
- preconditions: JSONB (실행 전 조건)
{
"status": ["PENDING", "REVIEW"],
"user_role": ["MANAGER", "ADMIN"]
}
- effects: JSONB (실행 후 효과)
{
"update_properties": {"status": "APPROVED"},
"create_link": {"link_type": "ApprovedBy"},
"send_notification": true
}
- implementation: TEXT (Python 코드 또는 SQL)
- is_active: BOOLEAN
- created_at: TIMESTAMP
```

==== Pipelines (데이터 파이프라인) ====

```
ontology_pipelines
- id: UUID PRIMARY KEY
- pipeline_name: VARCHAR(100)
- description: TEXT
- source_config: JSONB
{
"type": "database/api/file",
"connection": "...",
"query": "..."
}
- transformations: JSONB
[
{
"type": "map",
"source_field": "emp_name",
"target_property": "full_name"
},
{
"type": "filter",
"condition": "salary > 50000"
}
]
- target_object_type_id: UUID FK
- schedule: VARCHAR(100) (cron 표현식)
- is_active: BOOLEAN
- last_run_at: TIMESTAMP
- created_at: TIMESTAMP
```

==== Object Instances (객체 인스턴스) ====

```
ontology_object_instances
- id: UUID PRIMARY KEY
- object_type_id: UUID FK
- display_title: VARCHAR(500) (동적 생성)
- properties: JSONB (모든 속성 값)
{
"employee_name": "홍길동",
"employee_number": "E12345",
"hire_date": "2024-01-15",
"salary": 50000000
}
- base_record_id: VARCHAR(100) (원본 테이블 PK)
- tags: TEXT[] (검색용 태그)
- version: INTEGER (버전 관리)
- created_at: TIMESTAMP
- updated_at: TIMESTAMP
- created_by: VARCHAR(100)
```

=== 주요 모듈 기능 설명 ===

==== ontology/engine/inference_engine.py ====

**기능**: 온톨로지 기반 추론

- 객체 타입 상속 관계에서 속성 자동 상속
- 링크 타입 체인을 통한 간접 관계 추론
- 속성 값 기반 자동 분류 (예: 급여 범위로 직급 추론)
- 누락된 링크 자동 제안
- 제약조건 충돌 탐지

==== ontology/engine/validation_engine.py ====

**기능**: 온톨로지 규칙 검증

- 속성 타입 검증 (데이터 타입, 범위, 패턴)
- 필수 속성 검증
- 링크 카디널리티 검증 (ONE_TO_MANY 등)
- 순환 참조 탐지
- 비즈니스 규칙 검증 (사용자 정의 규칙)

==== core/discovery/relationship_detector.py ====

**기능**: 테이블 간 관계 자동 감지

- FK 제약조건 분석하여 링크 타입 자동 생성
- 컬럼명 패턴 분석 (예: dept_id → Department 링크)
- 데이터 분포 분석으로 숨겨진 관계 발견
- M:N 관계 중간 테이블 자동 인식
- 추천 신뢰도 점수 제공

==== core/generator/object_crud_gen.py ====

**기능**: 객체 기반 CRUD 생성

- Object Type 기반 동적 API 엔드포인트 생성
- Property Type에 따른 입력 폼 자동 생성
- 유효성 검사 로직 자동 생성
- 파일 업로드 속성 자동 처리
- 버전 관리 기능 포함

===== core/generator/link_crud_gen.py =====

**기능**: 링크 기반 CRUD 생성

- 링크 생성/삭제 API 생성
- 양방향 링크 자동 처리
- 링크 탐색 UI 생성 (그래프 뷰)
- 링크 속성 편집 기능
- 연쇄 링크 생성 (여러 객체 동시 연결)

==== core/generator/action_gen.py ====

**기능**: 액션 코드 자동 생성

- Action Type 정의에서 Python 함수 생성
- Preconditions를 데코레이터로 변환
- Effects를 트랜잭션으로 실행
- 액션 히스토리 자동 기록
- 롤백 메커니즘 포함

==== core/intelligence/auto_linker.py ====

**기능**: 지능형 자동 링크 생성

- 객체 속성 유사도 분석
- 텍스트 매칭 (이름, 코드 등)
- 기존 링크 패턴 학습
- 자동 링크 제안 및 확률 점수
- 배치 링크 생성

==== services/graph_service.py ====

**기능**: 그래프 탐색 서비스

- BFS/DFS 그래프 탐색
- 최단 경로 찾기
- N-hop 관계 조회
- 서브그래프 추출
- 영향도 분석 (한 객체 변경 시 연관 객체)

==== services/search_service.py ====

**기능**: 온톨로지 기반 검색

- 전문 검색 (Elasticsearch)
- 속성 기반 필터링
- 링크 기반 검색 (연결된 객체 찾기)
- 패싯 검색 (속성별 그룹핑)
- 자연어 쿼리 지원

==== api/v1/ontology.py ====

**기능**: 온톨로지 관리 API

```
POST /api/v1/ontology/object-types # 객체 타입 생성
GET /api/v1/ontology/object-types # 전체 온톨로지 조회
PUT /api/v1/ontology/object-types/{id} # 객체 타입 수정
DELETE /api/v1/ontology/object-types/{id} # 객체 타입 삭제

POST /api/v1/ontology/property-types # 속성 타입 생성
POST /api/v1/ontology/link-types # 링크 타입 생성
POST /api/v1/ontology/action-types # 액션 타입 생성

GET /api/v1/ontology/schema # 전체 스키마 내보내기
POST /api/v1/ontology/schema/import # 스키마 가져오기
```

==== api/v1/objects.py ====

**기능**: 객체 인스턴스 API

```
GET /api/v1/objects/{type} # 객체 목록 조회
POST /api/v1/objects/{type} # 객체 생성
GET /api/v1/objects/{type}/{id} # 객체 상세 조회
PUT /api/v1/objects/{type}/{id} # 객체 수정
DELETE /api/v1/objects/{type}/{id} # 객체 삭제

GET /api/v1/objects/{type}/{id}/links # 연결된 링크 조회
GET /api/v1/objects/{type}/{id}/history # 변경 이력
POST /api/v1/objects/{type}/{id}/actions/{action} # 액션 실행
```

==== api/v1/graph.py ====

**기능**: 그래프 탐색 API

```
GET /api/v1/graph/explore/{object_id} # 객체 중심 그래프 탐색
GET /api/v1/graph/path/{from}/{to} # 두 객체 간 경로
GET /api/v1/graph/neighbors/{object_id} # 인접 객체
POST /api/v1/graph/subgraph # 서브그래프 추출
GET /api/v1/graph/analytics/centrality # 중심성 분석
```

## 7. 프론트엔드 주요 컴포넌트

### 7.1 OntologyViewer.tsx

**기능**: 온톨로지 전체 시각화

- 객체 타입을 노드로 표시
- 링크 타입을 엣지로 연결
- 드래그앤드롭으로 레이아웃 조정
- 줌/팬 기능
- 타입 클릭 시 상세 정보 표시

### 7.2 ObjectGraph.tsx

**기능**: 객체 관계 그래프

- 선택한 객체와 연결된 객체들 시각화
- N-hop 깊이 조절
- 링크 타입별 색상 구분
- 노드 클릭 시 상세 페이지 이동
- 그래프 내 검색

### 7.3 DynamicForm.tsx

**기능**: 동적 폼 생성

- Property Type 정의에서 자동 폼 생성
- 타입별 입력 위젯 (text, number, date, select, file)
- 실시간 유효성 검사
- 조건부 필드 표시
- 파일 업로드 통합

### 7.4 ActionPanel.tsx

**기능**: 액션 실행 패널

- 객체에 적용 가능한 액션 목록
- 액션 파라미터 입력 폼
- Precondition 검증 결과 표시
- 액션 실행 진행 상태
- 실행 결과 및 에러 표시

### 7.5 OntologySearch.tsx

**기능**: 온톨로지 기반 검색

- 객체 타입 선택
- 속성 기반 필터
- 링크 기반 필터 (예: “Manager가 ‘홍길동’인 Employee”)
- 검색 결과 그리드/그래프 토글
- 저장된 검색 쿼리

## 8. 워크플로우

### 8.1 온톨로지 자동 구축 프로세스

```
1. 기존 SQLite/Oracle 테이블 스캔
↓
2. schema_scanner가 테이블/컬럼 메타데이터 추출
↓
3. relationship_detector가 FK 및 패턴으로 관계 감지
↓
4. ontology_mapper가 자동 매핑
- 테이블 → Object Type
- 컬럼 → Property Type
- FK → Link Type
↓
5. 사용자 검토 및 수정
- 타입명 변경
- 추가 링크 정의
- 비즈니스 규칙 추가
↓
6. Object Registry에 등록
↓
7. CRUD 및 UI 자동 생성
```

### 8.2 객체 생성 및 링크 연결

```
1. 사용자가 객체 생성 폼 작성
↓
2. validation_engine이 검증
- 속성 타입 검증
- 필수 속성 확인
- 비즈니스 규칙 검증
↓
3. 객체 인스턴스 저장
- ontology_object_instances 테이블
- 원본 테이블 (선택)
- Elasticsearch 색인
↓
4. auto_linker가 추천 링크 생성
- 유사 객체 찾기
- 기존 패턴 학습
↓
5. 사용자가 링크 확인/추가
↓
6. 링크 인스턴스 저장
- ontology_link_instances 테이블
- Neo4j 그래프 DB
```

### 8.3 액션 실행 프로세스

```
1. 사용자가 객체에서 액션 선택
↓
2. Precondition 검증
- 객체 상태 확인
- 사용자 권한 확인
↓
3. 액션 파라미터 입력
↓
4. 액션 실행
- 트랜잭션 시작
- 속성 업데이트
- 링크 생성/삭제
- 알림 발송
↓
5. Effects 적용
↓
6. 액션 히스토리 기록
↓
7. 실시간 업데이트 (WebSocket)
```

### 8.4 그래프 탐색 시나리오

```
예: "홍길동과 관련된 모든 프로젝트 찾기"

1. OntologySearch에서 "Employee" 타입 선택
↓
2. 속성 필터: name = "홍길동"
↓
3. 링크 필터: "WorksOn" → "Project"
↓
4. graph_service.find_linked_objects() 호출
↓
5. Neo4j 쿼리 실행:
MATCH (e:Employee {name: '홍길동'})-[:WorksOn]->(p:Project)
RETURN p
↓
6. 결과를 NetworkGraph로 시각화
```

## 9. 환경 설정

### 9.1 .env

```env
# FastAPI 설정
APP_NAME=Ontology CRUD System
APP_VERSION=1.0.0
DEBUG=True
SECRET_KEY=your-secret-key

# SQLite 설정
DATABASE_TYPE=sqlite
SQLITE_DB_PATH=./instance/app.db

# PostgreSQL 설정
POSTGRES_HOST=localhost
POSTGRES_PORT=5432
POSTGRES_DB=ontology_db
POSTGRES_USER=postgres
POSTGRES_PASSWORD=password

# Oracle 설정
ORACLE_USER=your_user
ORACLE_PASSWORD=your_password
ORACLE_DSN=localhost:1521/ORCL

# Neo4j 설정
NEO4J_URI=bolt://localhost:7687
NEO4J_USER=neo4j
NEO4J_PASSWORD=password

# Elasticsearch 설정
ES_HOST=localhost
ES_PORT=9200

# 파일 업로드
MAX_FILE_SIZE=10485760
UPLOAD_DIR=./uploads

# UI 설정
DEFAULT_THEME=shadcn
ENABLE_DARK_MODE=True
```

### 9.2 config.py

```python
# 환경별 설정 클래스
# DB 연결 풀 설정
# 캐시 설정
# 로깅 설정
```

## 10. 핵심 개선 사항 요약

### 10.1 단순 테이블 CRUD → 온톨로지 기반 객체 관리

- **Before**: 테이블별 독립적 CRUD
- **After**: 객체 타입 중심의 통합 관리, 상속 및 다형성 지원

### 10.2 암묵적 관계 → 명시적 링크 타입

- **Before**: FK만으로 관계 표현
- **After**: 의미있는 링크 타입 (WorksFor, Manages 등), 링크 속성 지원

### 10.3 정적 화면 → 동적 생성

- **Before**: 테이블당 고정 CRUD 화면
- **After**: 온톨로지 메타데이터 기반 실시간 UI 생성

### 10.4 단순 검색 → 지능형 검색

- **Before**: 컬럼 값 기반 검색
- **After**: 관계 탐색, 그래프 쿼리, 추론 기반 검색

### 10.5 수동 관계 설정 → 자동 발견

- **Before**: 개발자가 수동으로 관계 정의
- **After**: AI 기반 자동 관계 감지 및 링크 제안

### 10.6 CRUD만 → 비즈니스 액션

- **Before**: 기본 CRUD만 지원
- **After**: 도메인 특화 액션 (승인, 이관, 병합 등) 정의 및 실행

### 10.7 단일 DB → 하이브리드 아키텍처

- **Before**: 관계형 DB만 사용
- **After**: 관계형 DB + 그래프 DB + 검색 엔진 조합

이 설계는 Palantir Foundry의 핵심 개념인 **유연한 데이터 모델링**, **관계 중심 사고**, **지능형 자동화**를 적용하여 단순 CRUD를 넘어 엔터프라이즈급 데이터 관리 플랫폼으로 발전시킵니다.

팔란티어 온톨로지 프로그램 예제 - 편집 역사