feat: 온톨로지 자동 구축 + 벤치마크 프레임워크 + 검색 엔진 개선

## 온톨로지 자동 구축 (코어)
- KindClassifier 프로토콜 + RuleBasedClassifier: 키워드 기반 NodeKind 자동 분류
- RelationDetector 프로토콜 + RuleBasedRelationDetector: 역인덱스 기반 자동 Edge 탐지
  - title 언급 → RELATED, tag overlap → RELATED, embedding cosine similarity → RELATED
  - NodeKind 쌍 규칙: RULE→CONCEPT=DEPENDS_ON, LESSON→*=LEARNED_FROM
- graph.add()에서 kind=None이면 자동 분류, relation_detector 있으면 자동 관계 생성
- InvertedIndex로 O(1) 후보 조회 (전체 노드 순회 없음)

## 벤치마크 프레임워크
- 외부 데이터셋 8종: Ko-StrategyQA, AutoRAG, KLUE-MRC, HotPotQA, Allganize RAG-Eval/ko, PublicHealthQA
- 7단계 Ablation Study: S0 Flat → S1 +Ontology → S2 +Relations → S3 +Hebbian → S4 +Consolidation → S5 Full → S6 Auto → S7 Auto+Embed
- OntologyMapper (벤치마크용 batch 분류기), SessionSimulator (Hebbian 시뮬레이션)

## 검색 엔진 개선
- spreading activation 감쇠 0.5→0.25, depth 2→1: S2 MRR 하락 완전 해소 (0.547→0.772)
- 합산 부스트 0.3→0.1: FTS 직접 매칭 랭킹 보존
- ResonanceWeights relevance 0.4→0.55: 쿼리 관련성 우선 랭킹
- agent_search kind 필터 fallback: 결과 부족 시 필터 없이 재검색 (S5 MRR +19%)
- intent별 relevance 가중치 상향 (0.25~0.35 → 0.40~0.45)

## 벤치마크 결과 (FTS only, MemoryBackend)
- Allganize RAG-Eval: MRR 0.793, R@10 0.870
- HotPotQA-24: MRR 0.754, SF Recall 72.9%
- AutoRAG: MRR 0.639, R@10 0.800

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: SonAIengine

CLAUDE.md

@@ -0,0 +1,181 @@
+# Synaptic Memory — 프로젝트 지침
+
+## 프로젝트 개요
+LLM/멀티에이전트용 뇌 기반 지식 그래프 라이브러리 + MCP 서버.
+에이전트가 경험을 구조화하고, 과거 패턴을 검색/추론할 수 있게 하는 적응형 메모리 아키텍처.
+
+- PyPI: `synaptic-memory` (v0.5.0 배포 완료)
+- 라이선스: MIT
+- Python: >=3.12
+
+## 아키텍처
+
+### 핵심 모듈
+| 모듈 | 역할 |
+|------|------|
+| `graph.py` | SynapticGraph — 메인 facade (add, search, link, reinforce, consolidate) |
+| `search.py` | HybridSearch — 3단계 폴백 (FTS → fuzzy → synonym → rewriter) + spreading activation |
+| `agent_search.py` | AgentSearch — intent 기반 검색 (similar_decisions, past_failures, related_rules 등) |
+| `resonance.py` | ResonanceScorer — 4축 공명 (relevance × importance × recency × vitality) |
+| `hebbian.py` | HebbianEngine — co-activation 강화/약화 |
+| `consolidation.py` | ConsolidationCascade — L0→L1→L2→L3 메모리 정리 |
+| `ontology.py` | OntologyRegistry — 타입 계층, 관계 제약, 검증 |
+| `activity.py` | ActivityTracker — 에이전트 세션/tool call/결정/결과 추적 |
+| `models.py` | Node, Edge, NodeKind, EdgeKind, SearchResult 등 |
+
+### 백엔드 (7종)
+| 백엔드 | 용도 | 의존성 |
+|--------|------|--------|
+| `MemoryBackend` | 테스트/개발 | 없음 |
+| `SQLiteBackend` | 경량 프로덕션 | aiosqlite |
+| `PostgreSQLBackend` | 프로덕션 | asyncpg, pgvector |
+| `Neo4jBackend` | 그래프 탐색 | neo4j |
+| `QdrantBackend` | 벡터 검색 | qdrant-client |
+| `MinIOBackend` | 대용량 콘텐츠 | miniopy-async |
+| `CompositeBackend` | 용도별 분리 | Neo4j + Qdrant + MinIO |
+
+## 테스트
+
+### 인프라 요구사항
+```bash
+# Neo4j (테스트용 인증: neo4j/password)
+docker run -d --name neo4j -p 7474:7474 -p 7687:7687 \
+  -e NEO4J_AUTH=neo4j/password neo4j:5-community
+
+# Qdrant
+docker start qdrant  # 또는 docker run -d --name qdrant -p 6333:6333 qdrant/qdrant
+
+# PostgreSQL — 기존 컨테이너 사용 (ailab:ailab123@localhost:5432/plateerag)
+# MinIO — 기존 컨테이너 사용 (localhost:9000)
+```
+
+### 실행
+```bash
+# 전체 테스트 (281건)
+uv run pytest tests/ -v
+
+# PostgreSQL 제외 (asyncpg 미설치 시)
+uv run pytest tests/ --ignore=tests/test_backend_postgresql.py -v
+
+# 벤치마크만
+uv run pytest tests/benchmark/ -v -s
+```
+
+### Qdrant 테스트 주의
+- fixture에서 매 테스트 전 `test_synaptic` collection 삭제 후 재생성
+- 이전 비정상 종료 시 segment 잔재로 500 에러 발생 가능 → collection 수동 삭제 후 재실행
+
+## 벤치마크
+
+### 구조
+```
+tests/benchmark/
+├── conftest.py                    # 엔터프라이즈 시나리오 fixture
+├── metrics.py                     # IR 평가 지표 (MRR, nDCG, P@K, R@K, F1@K)
+├── generate_data.py               # 시나리오 데이터 생성기 (아직 미사용)
+├── download_datasets.py           # HuggingFace 외부 데이터셋 다운로드
+├── test_enterprise_benchmark.py   # 자체 시나리오 벤치마크 (50개 쿼리)
+├── test_external_datasets.py      # 외부 데이터셋 벤치마크
+└── data/
+    ├── enterprise_scenario.json   # 자체 시나리오 v1 (12 지식 + 4 세션 + 15 쿼리)
+    ├── ko_strategyqa.json         # MTEB Ko-StrategyQA (9.2K corpus, 592 queries)
+    ├── autorag_retrieval.json     # MTEB AutoRAGRetrieval (720 corpus, 114 queries)
+    └── klue_mrc.json              # KLUE-MRC (5.8K corpus, 5.8K queries)
+```
+
+### 외부 데이터셋 다운로드
+```bash
+uv run python tests/benchmark/download_datasets.py
+```
+- MIRACL, Mr. TyDi는 HuggingFace datasets 호환 이슈로 현재 skip
+
+### 외부 데이터셋 벤치마크 결과 (FTS only, MemoryBackend)
+| 데이터셋 | Corpus | Queries | MRR | nDCG@10 | R@10 |
+|----------|--------|---------|-----|---------|------|
+| Allganize RAG-Eval | 300 | 300 | 0.796 | 0.811 | 0.863 |
+| Allganize rag-ko | 200 | 200 | 0.780 | 0.797 | 0.855 |
+| HotPotQA-24 | 226 | 24 | 0.754 | 0.636 | 0.729 |
+| HotPotQA-200 | 1990 | 200 | 0.742 | 0.599 | 0.652 |
+| AutoRAGRetrieval | 720 | 114 | 0.646 | 0.681 | 0.798 |
+| KLUE-MRC | 500 | 100 | 0.607 | 0.643 | 0.760 |
+| PublicHealthQA | 77 | 77 | 0.342 | 0.390 | 0.558 |
+| Ko-StrategyQA | 9,251 | 100 | 0.315 | 0.261 | 0.293 |
+
+### 자체 시나리오 벤치마크 결과 (v0.5.0 + 검색 개선)
+| 지표 | Baseline | 개선 후 |
+|------|----------|--------|
+| MRR | 0.326 | **0.477** (+46%) |
+| Mean P@5 | 0.160 | **0.227** (+42%) |
+| Mean R@5 | 0.467 | **0.533** (+14%) |
+| Mean nDCG@5 | 0.351 | **0.431** (+23%) |
+| Hit rate | 9/15 | **13/15** |
+
+### Ablation Study 핵심 발견
+- S1 Ontology: 현재 graph.search()가 NodeKind를 랭킹에 미활용 → 효과 없음
+- S2 Relations: spreading activation이 노이즈 유입 (MRR -14~-32%)
+- S3 Hebbian: HotPotQA multi-hop에서만 +3.9% 기여
+- S5 agent_search: kind 필터링이 과도하게 공격적 → recall 하락
+- S6 Auto ontology: 보수적 동작으로 성능 유지하지만 개선도 없음
+
+### 경쟁 제품 비교
+| 제품 | 벤치마크 | 결과 | 비고 |
+|------|----------|------|------|
+| Cognee | HotPotQA 24문항 | Correctness 0.925 | end-to-end QA (LLM 포함) |
+| Mem0 | LoCoMo | 66.9% | 메모리 정확도 |
+| LightRAG | NaiveRAG 비교 | 39% win rate | 독립 검증 (원래 66.7%) |
+| HippoRAG2 | HotPotQA | Recall 95.4% | 최고 수준 |
+
+### 검색 개선 내역
+1. FTS: title 가중치 3x, bigram 서브스트링 매칭, tag 매칭
+2. FTS: 순위 기반 점수 (1위 0.95 → 감소)
+3. Fuzzy: threshold 0.3→0.4, content 샘플 50→100 단어, title boost
+4. Spreading activation: depth 1→2, 다중 경로 보상
+5. AgentSearch past_failures: LESSON 노드 포함, fallback 추가
+
+## 배포
+
+### PyPI
+```bash
+source ~/.claude/.secrets  # PYPI_TOKEN 로드
+uv build && uv publish --username __token__ --password "$PYPI_TOKEN"
+```
+
+### 설치
+```bash
+pip install synaptic-memory            # 코어만
+pip install synaptic-memory[embedding]  # auto-embedding
+pip install synaptic-memory[scale]      # Neo4j + Qdrant + MinIO
+pip install synaptic-memory[all]        # 전부
+pip install synaptic-memory[mcp]       # MCP 서버
+```
+
+## 로드맵
+
+### 온톨로지 자동 구축 (3단계)
+| Phase | 방식 | 비용 | 한국어 | 의존성 |
+|-------|------|------|--------|--------|
+| Phase 1 | 임베딩 유사도 자동 연결 | 저렴 | O | sentence-transformers |
+| Phase 2 | spaCy dependency parsing | 무료 | 제한적 | spacy (ko_core_news) |
+| Phase 3 | LLM 프롬프트 트리플 추출 | 높음 | O | LLM API |
+
+### 검색 엔진 개선 포인트
+- spreading activation 가중치 튜닝: edge type별 차등 전파 (RELATED > TAGGED_WITH)
+- NodeKind 활용: 검색 랭킹에 kind 정보 반영 (ontology ablation 결과 반영)
+- tag 기반 부스팅: tag 매칭 시 가중치 조절
+- agent_search kind 필터 완화: recall 보존하면서 precision 유지
+
+### 타겟 수치
+| 지표 | 현재 (최고) | 목표 | 근거 |
+|------|-------------|------|------|
+| MRR (Allganize) | 0.796 | 0.85+ | FTS+embedding 결합 시 |
+| MRR (HotPotQA-200) | 0.742 | 0.80+ | spreading activation 개선 시 |
+| MRR (Ko-StrategyQA) | 0.315 | 0.50+ | embedding 필수 (9K corpus) |
+| 자체 시나리오 MRR | 0.477 | 0.65+ | ontology+embedding 결합 |
+
+## 방향성
+- 플래티어 온톨로지 비전과 연계: 엔터프라이즈 시맨틱 레이어
+- 정적 검색 → 동적 메모리 (사용 경험에 따라 재편)
+- 다층 랭킹: relevance + importance + recency + vitality
+- Hebbian 학습: 함께 쓰이는 지식 연결 강화, 실패 패턴 약화
+- 선제적 활성화: 태스크 맥락 기반 proactive loading
+- **차별점**: 단순 retrieval이 아닌 "에이전트 경험 메모리" — 검색+학습+적응의 통합

src/synaptic/__init__.py

@@ -4,7 +4,9 @@
 
 from synaptic.activity import ActivityTracker
 from synaptic.agent_search import AgentSearch, SearchIntent, suggest_intent
+from synaptic.extensions.classifier_rules import RuleBasedClassifier
 from synaptic.extensions.embedder import EmbeddingProvider, MockEmbeddingProvider
+from synaptic.extensions.relation_detector import RuleBasedRelationDetector
 from synaptic.graph import SynapticGraph
 from synaptic.models import (
     ActivatedNode,
@@ -23,7 +25,15 @@
     TypeDef,
     build_agent_ontology,
 )
-from synaptic.protocols import Digester, GraphTraversal, QueryRewriter, StorageBackend, TagExtractor
+from synaptic.protocols import (
+    Digester,
+    GraphTraversal,
+    KindClassifier,
+    QueryRewriter,
+    RelationDetector,
+    StorageBackend,
+    TagExtractor,
+)
 from synaptic.resonance import ResonanceWeights
 
 __version__ = "0.5.0"
@@ -39,14 +49,18 @@
     "EdgeKind",
     "EmbeddingProvider",
     "GraphTraversal",
+    "KindClassifier",
     "MockEmbeddingProvider",
     "Node",
     "NodeKind",
     "OntologyRegistry",
     "PropertyDef",
     "QueryRewriter",
+    "RelationDetector",
     "RelationConstraint",
     "ResonanceWeights",
+    "RuleBasedClassifier",
+    "RuleBasedRelationDetector",
     "SearchIntent",
     "SearchResult",
     "StorageBackend",

src/synaptic/agent_search.py

@@ -31,19 +31,19 @@ class SearchIntent(StrEnum):
 # Weights tuned per intent
 _INTENT_WEIGHTS: dict[SearchIntent, ResonanceWeights] = {
     SearchIntent.SIMILAR_DECISIONS: ResonanceWeights(
-        relevance=0.30, importance=0.30, recency=0.15, vitality=0.05, context=0.20,
+        relevance=0.45, importance=0.20, recency=0.15, vitality=0.05, context=0.15,
     ),
     SearchIntent.PAST_FAILURES: ResonanceWeights(
-        relevance=0.25, importance=0.35, recency=0.20, vitality=0.05, context=0.15,
+        relevance=0.40, importance=0.25, recency=0.20, vitality=0.05, context=0.10,
     ),
     SearchIntent.RELATED_RULES: ResonanceWeights(
-        relevance=0.35, importance=0.25, recency=0.10, vitality=0.10, context=0.20,
+        relevance=0.45, importance=0.20, recency=0.10, vitality=0.10, context=0.15,
     ),
     SearchIntent.REASONING_CHAIN: ResonanceWeights(
-        relevance=0.30, importance=0.20, recency=0.25, vitality=0.05, context=0.20,
+        relevance=0.40, importance=0.20, recency=0.20, vitality=0.05, context=0.15,
     ),
     SearchIntent.CONTEXT_EXPLORE: ResonanceWeights(
-        relevance=0.20, importance=0.15, recency=0.15, vitality=0.10, context=0.40,
+        relevance=0.30, importance=0.15, recency=0.15, vitality=0.10, context=0.30,
     ),
 }
 
@@ -155,11 +155,15 @@ async def _search_similar_decisions(
         start = time()
         weights = _INTENT_WEIGHTS[SearchIntent.SIMILAR_DECISIONS]
 
-        # Search filtered to decision nodes
+        # Search filtered to decision nodes, fallback to unfiltered
         result = await self._hybrid.search(
             backend, query, limit=limit * 2, embedding=embedding,
             node_kinds=[NodeKind.DECISION],
         )
+        if len(result.nodes) < 2:
+            result = await self._hybrid.search(
+                backend, query, limit=limit * 2, embedding=embedding,
+            )
 
         # Expand: follow RESULTED_IN edges to include outcomes
         expanded: dict[str, tuple[Node, float]] = {}
@@ -189,21 +193,23 @@ async def _search_past_failures(
         limit: int,
         context_tags: list[str] | None,
     ) -> SearchResult:
-        """Find failed outcomes and their decision context."""
+        """Find failed outcomes, lessons, and their decision context."""
         start = time()
         weights = _INTENT_WEIGHTS[SearchIntent.PAST_FAILURES]
 
-        # Search OUTCOME nodes
+        # Search broadly — OUTCOME, DECISION, LESSON all relevant to failures
         result = await self._hybrid.search(
             backend, query, limit=limit * 3,
-            node_kinds=[NodeKind.OUTCOME, NodeKind.DECISION],
+            node_kinds=[NodeKind.OUTCOME, NodeKind.DECISION, NodeKind.LESSON],
         )
 
-        # Filter to failures and backtrack to decisions
         expanded: dict[str, tuple[Node, float]] = {}
         for an in result.nodes:
             node = an.node
-            if node.kind == NodeKind.OUTCOME and node.failure_count > 0:
+            # LESSON 노드는 장애 교훈이므로 직접 포함
+            if node.kind == NodeKind.LESSON:
+                expanded[node.id] = (node, an.activation)
+            elif node.kind == NodeKind.OUTCOME and node.failure_count > 0:
                 expanded[node.id] = (node, an.activation)
                 # Backtrack to decision
                 edges = await backend.get_edges(node.id, direction="incoming")
@@ -215,7 +221,7 @@ async def _search_past_failures(
             elif node.kind == NodeKind.DECISION and node.failure_count > 0:
                 expanded[node.id] = (node, an.activation)
 
-        # Also find lessons learned from failures
+        # Also find lessons learned from failures via graph edges
         for node_id in list(expanded.keys()):
             edges = await backend.get_edges(node_id, direction="incoming")
             for edge in edges:
@@ -224,6 +230,14 @@ async def _search_past_failures(
                     if lesson and lesson.id not in expanded:
                         expanded[lesson.id] = (lesson, 0.6)
 
+        # If still empty, fall back to general search (no kind filter)
+        if not expanded:
+            result = await self._hybrid.search(
+                backend, query, limit=limit * 2,
+            )
+            for an in result.nodes:
+                expanded[an.node.id] = (an.node, an.activation)
+
         activated = self._score_candidates(expanded, weights, context_tags)
         return SearchResult(
             query=query,
@@ -249,6 +263,10 @@ async def _search_related_rules(
             backend, query, limit=limit * 2, embedding=embedding,
             node_kinds=[NodeKind.RULE, NodeKind.LESSON],
         )
+        if len(result.nodes) < 2:
+            result = await self._hybrid.search(
+                backend, query, limit=limit * 2, embedding=embedding,
+            )
 
         # Expand via graph traversal
         expanded: dict[str, tuple[Node, float]] = {}
@@ -280,11 +298,15 @@ async def _search_reasoning_chain(
         start = time()
         weights = _INTENT_WEIGHTS[SearchIntent.REASONING_CHAIN]
 
-        # Find seed decisions
+        # Find seed decisions, fallback to unfiltered
         result = await self._hybrid.search(
             backend, query, limit=limit,
             node_kinds=[NodeKind.DECISION],
         )
+        if len(result.nodes) < 2:
+            result = await self._hybrid.search(
+                backend, query, limit=limit,
+            )
 
         expanded: dict[str, tuple[Node, float]] = {}
         for an in result.nodes: