ltcai 0.1.24 → 0.1.25

package/README.md

@@ -294,7 +294,7 @@ Or: `./start_ai.sh` (auto-restart + caffeinate)
 | VS Code Marketplace | [marketplace.visualstudio.com](https://marketplace.visualstudio.com/items?itemName=parktaesoo.ltcai) |
 | Open VSX | [open-vsx.org](https://open-vsx.org/extension/parktaesoo/ltcai) |
 
-Current version: **0.1.24** — [Changelog](docs/CHANGELOG.md)
+Current version: **0.1.25** — [Changelog](docs/CHANGELOG.md)
 
 ---
 

package/docs/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## [0.1.25] - 2026-05-24
+
+### Knowledge Graph 전면 재설계 — 점=명사, 선=동사
+
+**설계 원칙**
+- **점(Node) = 명사** — 의미 있는 대상 (문서, 사람, 개념, 에러, 코드, 채팅 등)
+- **선(Edge) = 동사** — 대상 간의 관계 (언급함, 포함함, 해결함, 의존함 등)
+- 원본 데이터(PDF·PPT·채팅·코드 등)는 그대로 보관, AI가 핵심 개념을 추출해 점으로 만들고 관계를 선으로 연결
+
+**노드 타입 (점 = 명사)**
+- `Chat` — 대화 세션
+- `Document` — 파일 (PDF·PPT·Word·Excel·이미지)
+- `Concept` — 개념·아이디어·기술 용어
+- `Person` — 사람 (사용자, 언급된 인물)
+- `Error` — 오류·버그·예외
+- `Code` — 코드·함수·클래스
+- `Feature` — 소프트웨어 기능
+- `Task` — 할 일·액션 아이템
+- `Decision` — 결정 사항
+
+**엣지 어휘 (선 = 동사형)**
+`언급함` · `포함함` · `해결함` · `의존함` · `설명함` · `비교함` · `사용함` · `연결함` · `확장함` · `생성함` · `대체함` · `지원함` · `발생함` · `관련됨` · `작성함` · `업로드함`
+
+**핵심 개선**
+- `_extract_concepts()` — 고유명사·복합어·기술 용어 추출 (Lattice AI, Graph RAG, VS Code 등)
+- `_classify_node_type()` — 개념별 노드 타입 자동 분류 (윈도우 컨텍스트 기반)
+- `_infer_edge()` — 문장 내 동사·조사 패턴으로 엣지 레이블 자동 결정
+- `_extract_triples()` — 문장 단위 개념 쌍 → (주어, 동사, 목적어) 트리플 추출
+- `ingest_message()` 재설계 — 메시지 단위 → 대화 세션(Chat) 단위 노드
+- `ingest_document()` 재설계 — Document 노드 + 동사형 엣지 (포함함, 업로드함)
+- 중복 제거 — 하위 개념이 상위 복합어에 완전히 흡수될 때만 제거
+- Message·AIResponse·Chunk 노드는 RAG 검색용으로만 저장, 그래프 비표시
+
+### Release
+- 배포 버전을 `0.1.25`로 상향
+- 대상 채널: `npm` · `PyPI` · `VS Code Marketplace` · `Open VSX`
+
 ## [0.1.24] - 2026-05-24
 
 ### 안정화 및 UX 개선

package/knowledge_graph.py

@@ -94,31 +94,274 @@ def _chunks(text: str, size: int = 1200, overlap: int = 160) -> List[str]:
     return chunks
 
 
-def _topic_candidates(text: str, limit: int = 8) -> List[str]:
+_CONCEPT_STOP: set = {
+    # English stop words
+    "the", "and", "for", "with", "this", "that", "from", "into", "which",
+    "are", "was", "were", "has", "have", "had", "can", "will", "would",
+    "could", "should", "may", "might", "must", "shall", "being", "been",
+    "also", "just", "then", "than", "when", "where", "what", "how", "why",
+    "its", "their", "your", "our", "you", "they", "them", "these", "those",
+    "use", "used", "using", "based", "like", "such", "via", "per", "let",
+    "yes", "not", "but", "are", "all", "any", "out", "new", "get", "set",
+    # Korean stop words
+    "사용자", "내용", "파일", "채팅", "답변", "입니다", "그리고", "처럼",
+    "있어", "없어", "이야", "이다", "한다", "하다", "되다", "됩니다",
+    "경우", "방법", "부분", "상태", "정도", "결과", "이후", "이전",
+    "그것", "이것", "저것", "여기", "거기", "저기", "우리", "저희",
+    "기능", "서버", "모델", "설정", "설명", "버전", "지원", "사용", "실행",
+    "todo", "fixme", "note", "참고", "주의", "warning",
+}
+
+
+def _extract_concepts(text: str, limit: int = 12) -> List[str]:
+    """Extract meaningful named concepts from text.
+
+    Priority order:
+    1. Backtick / quoted terms (explicitly technical)
+    2. Multi-word proper nouns (Lattice AI, GPT-4o, Claude Sonnet)
+    3. Single capitalized proper nouns not at sentence start (Claude, Python, FastAPI)
+    4. Korean compound technical terms (멀티모달, 에이전트, 그래프RAG)
+    5. Hyphenated / versioned identifiers (gpt-4o, mlx-lm, llama-3.3)
+    """
     text = str(text or "")
-    candidates: Dict[str, int] = {}
-    patterns = [
-        r"[A-Za-z][A-Za-z0-9_\-./]{2,}",
-        r"[가-힣][가-힣A-Za-z0-9_\-]{1,}",
-    ]
-    stop = {
-        "the", "and", "for", "with", "this", "that", "from", "into",
-        "사용자", "내용", "파일", "채팅", "답변", "입니다", "그리고", "처럼",
-    }
-    for pattern in patterns:
-        for match in re.findall(pattern, text):
-            key = match.strip("._-/").lower()
-            if (len(key) < 3 and not re.search(r"[가-힣]", key)) or key in stop or key.isdigit():
+    seen: dict = {}  # concept_lower → original form
+
+    def _add(term: str) -> None:
+        key = term.strip().lower()
+        if (
+            key
+            and key not in _CONCEPT_STOP
+            and not key.isdigit()
+            and len(key) >= 2
+        ):
+            seen.setdefault(key, term.strip())
+
+    # 1. Backtick-quoted code/term (highest confidence)
+    for m in re.findall(r'`([^`]{2,40})`', text):
+        if not re.search(r'[\(\)\[\]{}]', m):  # skip code expressions
+            _add(m)
+
+    # 2. Double/single quoted terms
+    for m in re.findall(r'"([^"]{2,40})"', text):
+        _add(m)
+
+    # 3. Multi-word English proper nouns (Title Case or ALL-CAPS first word, 2–4 words).
+    #    Pattern A: Mixed-case first word — "Lattice AI", "Tool Use", "Graph RAG"
+    for m in re.findall(
+        r'([A-Z][a-z]{1,20}(?:\s+(?:[A-Z]{2,10}|[A-Z][a-z0-9]{1,20}|\d[\w.]{0,6})){1,3})',
+        text,
+    ):
+        _add(m)
+    #    Pattern B: ALL-CAPS first word — "VS Code", "MCP Server", "GPT-4o Mini"
+    for m in re.findall(
+        r'([A-Z]{2,6}(?:\s+(?:[A-Z]{2,10}|[A-Z][a-z0-9]{1,20})){1,2})',
+        text,
+    ):
+        _add(m)
+
+    # 4. Single capitalized proper noun.
+    #    Use ASCII-boundary lookaround instead of \b so Korean particles
+    #    (와, 의, 는 …) after an English word don't block the match.
+    all_caps_words = re.findall(r'(?<![A-Za-z0-9])([A-Z][A-Za-z0-9]{2,24})(?![A-Za-z0-9])', text)
+    freq: Dict[str, int] = {}
+    for w in all_caps_words:
+        freq[w] = freq.get(w, 0) + 1
+    sentence_starts = set(re.findall(r'(?:^|(?<=[.!?])\s+)([A-Z][a-z]+)', text))
+    for m, cnt in freq.items():
+        if m.lower() in _CONCEPT_STOP:
+            continue
+        if cnt >= 2 or m not in sentence_starts:
+            _add(m)
+
+    # 5. Korean technical compound nouns (3–12 chars, no common particles)
+    for m in re.findall(r'[가-힣]{2,12}(?:AI|LLM|API|UI|RAG|bot|Bot|기능|모델|서버|에이전트|파이프라인|워크플로)', text):
+        _add(m)
+    # Korean standalone terms that appear after topic markers (은/는/이/가 앞)
+    for m in re.findall(r'([가-힣]{2,12})(?:은|는|이|가|을|를|의|에서|으로|와|과)', text):
+        if m.lower() not in _CONCEPT_STOP and len(m) >= 2:
+            # Only add if it's non-trivial (has 3+ chars or appears multiple times)
+            cnt = text.count(m)
+            if len(m) >= 3 or cnt >= 2:
+                _add(m)
+
+    # 6. Hyphenated / versioned identifiers (gpt-4o, llama-3.3, mlx-lm)
+    for m in re.findall(r'\b([a-zA-Z][a-zA-Z0-9]*(?:-[a-zA-Z0-9.]+)+)\b', text):
+        if len(m) >= 4:
+            _add(m)
+
+    # De-duplicate: remove shorter if ALL its occurrences in the source text
+    # are followed immediately by the suffix that forms the longer concept.
+    # "Lattice" → dropped when every occurrence is "Lattice AI"
+    # "Claude"  → kept  because it appears as just "Claude" too.
+    values = list(seen.values())
+    values_lower = [v.lower() for v in values]
+    keep = set(range(len(values)))
+    for i, v in enumerate(values):
+        vl = v.lower()
+        for j, wl in enumerate(values_lower):
+            if i == j or j not in keep:
+                continue
+            # Check if vl is a word-prefix of wl
+            suffix = wl[len(vl):]
+            if not (wl.startswith(vl) and re.match(r'^[\s\-]', suffix)):
                 continue
-            candidates[key] = candidates.get(key, 0) + 1
-    return [
-        k for k, v in sorted(candidates.items(), key=lambda item: (-item[1], item[0]))
-        if (re.search(r"[가-힣]", k) and len(k) >= 2) or (len(k) >= 4 and (v >= 2 or len(k) >= 6))
-    ][:limit]
+            # Count occurrences of v NOT followed by the suffix
+            suffix_stripped = suffix.lstrip(" -")
+            # Escape for regex
+            pattern_with_suffix = re.escape(v) + r'[\s\-]+' + re.escape(suffix_stripped)
+            pattern_alone = re.escape(v) + r'(?![\s\-]*' + re.escape(suffix_stripped) + r')'
+            alone_count = len(re.findall(pattern_alone, text, re.IGNORECASE))
+            if alone_count == 0:
+                # Shorter term never appears alone → safe to remove
+                keep.discard(i)
+                break
+
+    final = [values[i] for i in range(len(values)) if i in keep]
+    return final[:limit]
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Node type taxonomy  (점 = 명사)
+# ──────────────────────────────────────────────────────────────────────────────
+# Chat      — 대화 세션
+# Document  — 파일 (PDF·PPT·Word·Excel·이미지 등)
+# Concept   — 개념·아이디어·기술 용어
+# Person    — 사람 (사용자, 언급된 인물)
+# Error     — 오류·버그·예외
+# Code      — 코드 스니펫·함수·클래스
+# Feature   — 소프트웨어 기능
+# Task      — 할 일·액션 아이템
+# Decision  — 결정 사항
+
+# Edge type vocabulary  (선 = 동사 — 과거형 서술어)
+EDGE_VERB = {
+    "언급함":   r"언급|mention|refer|cited",
+    "포함함":   r"포함|include|consist|구성|탑재|contains",
+    "해결함":   r"해결|resolv|fix|수정|고쳤|closed",
+    "의존함":   r"의존|depend|require|필요|based on",
+    "설명함":   r"설명|explain|describe|정의|란|이란|means",
+    "비교함":   r"비교|versus|vs\.?|차이|다르|compare",
+    "사용함":   r"사용|use|활용|이용|apply",
+    "연결함":   r"연결|connect|통합|integrate|연동|link",
+    "확장함":   r"확장|extend|플러그인|plugin|addon",
+    "생성함":   r"생성|만들|create|generate|build|produced",
+    "대체함":   r"대체|replace|instead|alternative",
+    "지원함":   r"지원|support|제공|provide|offer",
+    "발생함":   r"발생|occur|throw|raise|triggered",
+    "관련됨":   r"관련|related|associated|연관",
+}
+
+
+def _infer_edge(sentence: str) -> str:
+    """Return the best-matching verb-form edge label for a sentence."""
+    s = sentence.lower()
+    for label, pattern in EDGE_VERB.items():
+        if re.search(pattern, s):
+            return label
+    return "관련됨"
+
+
+# Technical words that cannot be person names
+_NOT_PERSON_WORDS: set = {
+    "use", "api", "rag", "sdk", "ide", "cli", "llm", "mcp", "ui", "ux",
+    "new", "old", "get", "set", "run", "add", "fix", "tool", "code",
+    "base", "core", "data", "file", "test", "type", "mode", "view",
+}
+
+
+def _classify_node_type(concept: str, text: str) -> str:
+    """Classify a concept into the node taxonomy.
+
+    Term-level signals take priority; then a tight ±60-char window is used
+    so distant keywords don't cause mis-classification.
+    """
+    term = concept.lower()
+
+    # ── Term-level signals (highest confidence) ───────────────────────────
+    if re.search(r'(?:error|exception|traceback|오류|에러|버그)$', term, re.I):
+        return "Error"
+    if re.search(r'error|exception|err\b', term, re.I) and len(concept) < 30:
+        return "Error"
+    if re.search(r'\(\)|\.py$|\.js$|\.ts$|\.go$|::\w', term):
+        return "Code"
+
+    # Person: "First Last" pattern, neither word is a known technical term
+    if re.match(r'^[A-Z][a-z]{1,15} [A-Z][a-z]{1,15}$', concept):
+        words = term.split()
+        if not any(w in _NOT_PERSON_WORDS for w in words):
+            return "Person"
+
+    # ── Windowed context (±60 chars) — NOT used for Error to avoid false positives
+    idx = text.lower().find(term)
+    if idx >= 0:
+        win = text[max(0, idx - 60): idx + len(concept) + 60].lower()
+        if re.search(r'def |class |function|함수|클래스|메서드|import', win):
+            return "Code"
+        # Feature: concept appears DIRECTLY adjacent to 기능/feature keyword
+        if (
+            len(concept) <= 12
+            and re.search(
+                rf'{re.escape(term)}.{{0,8}}(?:기능|feature)|(?:기능|feature).{{0,8}}{re.escape(term)}',
+                win,
+            )
+        ):
+            return "Feature"
+
+    return "Concept"
+
+
+def _extract_triples(
+    text: str,
+    concepts: List[str],
+    limit: int = 20,
+) -> List[Dict[str, str]]:
+    """Extract (subject, verb-edge, object, context) triples from text.
+
+    For each sentence containing ≥2 concepts, infer the verb-form edge label
+    from surrounding context and create a directed triple.
+    """
+    if len(concepts) < 2:
+        return []
+
+    concept_lower = {c.lower(): c for c in concepts}
+    triples: List[Dict[str, str]] = []
+    seen_pairs: set = set()
+
+    # Split on sentence boundaries
+    sentences = re.split(r'(?<=[.!?\n])\s+|\n{2,}', text)
+    for sent in sentences:
+        sent = sent.strip()
+        if len(sent) < 8:
+            continue
+        sent_lower = sent.lower()
+
+        present = [concept_lower[k] for k in concept_lower if k in sent_lower]
+        if len(present) < 2:
+            continue
+
+        edge = _infer_edge(sent)
+
+        for i in range(len(present) - 1):
+            subj, obj = present[i], present[i + 1]
+            # Deduplicate by (subj, obj) regardless of direction for same edge
+            pair_key = tuple(sorted([subj.lower(), obj.lower()])) + (edge,)
+            if pair_key in seen_pairs:
+                continue
+            seen_pairs.add(pair_key)
+            triples.append({
+                "subject": subj,
+                "relation": edge,          # verb form (동사)
+                "object": obj,
+                "context": sent[:240],
+            })
+            if len(triples) >= limit:
+                return triples
+
+    return triples
 
 
 def _semantic_items(text: str) -> List[Dict[str, str]]:
-    """Lightweight extraction for product MVP before model-based IE is wired in."""
+    """Extract explicit decision / task items from text."""
     items: List[Dict[str, str]] = []
     for raw_line in str(text or "").splitlines():
         line = _clean_text(raw_line)
@@ -129,7 +372,7 @@ def _semantic_items(text: str) -> List[Dict[str, str]]:
             items.append({"type": "Decision", "title": line[:120], "summary": line[:500]})
         if re.search(r"(todo|해야|하자|진행|구현|수정|확인|next|task|\[ \])", lowered):
             items.append({"type": "Task", "title": line[:120], "summary": line[:500]})
-    return items[:12]
+    return items[:8]
 
 
 class KnowledgeGraphStore:
@@ -268,54 +511,108 @@ class KnowledgeGraphStore:
             "user_nickname": user_nickname,
             "chars": len(content),
         }
+        concepts = _extract_concepts(content)
+        triples  = _extract_triples(content, concepts)
+        semantic = _semantic_items(content)
+
         with self._connect() as conn:
-            self._upsert_node(conn, conv_id, "Conversation", conversation_id or "Default conversation", metadata={"source": source})
+            # ── 1. Chat node  (점: 명사 — 대화 세션 단위) ─────────────────────
+            #    One Chat node per conversation_id; title = first 80 chars of
+            #    the first user message in this session (updated on each call).
+            chat_title = _clean_text(content)[:80] or (conversation_id or "대화")
+            self._upsert_node(
+                conn, conv_id, "Chat",
+                chat_title,
+                summary=_clean_text(content)[:400],
+                metadata={"source": source, "conversation_id": conversation_id},
+            )
+
+            # ── 2. Person node  (점: 명사 — 사람) ─────────────────────────────
+            person_id = None
+            if user_email or user_nickname:
+                person_key = user_email or user_nickname or "unknown"
+                person_id = f"person:{_slug(person_key)}"
+                self._upsert_node(
+                    conn, person_id, "Person",
+                    user_nickname or user_email or "Unknown",
+                    metadata={"email": user_email, "nickname": user_nickname},
+                )
+                # 선: 동사 — Person이 Chat을 "작성함"
+                self._upsert_edge(conn, person_id, conv_id, "작성함",
+                                  weight=1.0, metadata={"role": role})
+
+            # ── 3. Raw message node  (RAG 검색용, 그래프에서 숨김) ─────────────
             self._upsert_node(
-                conn,
-                node_id,
-                node_type,
+                conn, node_id, node_type,
                 _clean_text(content)[:80] or role,
                 summary=_clean_text(content)[:500],
                 metadata=metadata,
                 raw=raw or metadata,
             )
-            self._upsert_edge(conn, conv_id, node_id, "contains", metadata={"source": source})
-            if user_email or user_nickname:
-                person_key = user_email or user_nickname or "unknown"
-                person_id = f"person:{_slug(person_key)}"
-                self._upsert_node(conn, person_id, "Person", user_nickname or user_email or "Unknown user", metadata={"email": user_email})
-                self._upsert_edge(conn, person_id, node_id, "authored", metadata={"role": role})
+            # 선: Chat이 메시지를 "포함함"
+            self._upsert_edge(conn, conv_id, node_id, "포함함",
+                              weight=0.3, metadata={"role": role})
+
+            # ── 4. RAG chunks  (검색용, 그래프에서 숨김) ──────────────────────
             for index, chunk in enumerate(_chunks(content)):
                 chunk_id = f"chunk:{_sha256_text(f'{node_id}:{index}:{chunk}')[:24]}"
-                self._upsert_node(conn, chunk_id, "Chunk", f"{node_type} chunk {index + 1}", summary=chunk[:500], metadata={"index": index, "source_node": node_id})
+                self._upsert_node(
+                    conn, chunk_id, "Chunk",
+                    f"chunk {index + 1}",
+                    summary=chunk[:500],
+                    metadata={"index": index, "source_node": node_id},
+                )
                 conn.execute(
-                    """
-                    INSERT OR REPLACE INTO chunks(id, source_node, text, metadata_json, created_at)
-                    VALUES (?, ?, ?, ?, ?)
-                    """,
-                    (chunk_id, node_id, chunk, _json({"index": index, "source_node": node_id}), _now()),
+                    "INSERT OR REPLACE INTO chunks(id, source_node, text, metadata_json, created_at) "
+                    "VALUES (?, ?, ?, ?, ?)",
+                    (chunk_id, node_id, chunk,
+                     _json({"index": index, "source_node": node_id}), _now()),
                 )
-                self._upsert_edge(conn, node_id, chunk_id, "has_chunk")
-            for topic in _topic_candidates(content):
-                topic_id = f"topic:{_slug(topic)}"
-                self._upsert_node(conn, topic_id, "Topic", topic, metadata={"auto_extracted": True})
-                self._upsert_edge(conn, node_id, topic_id, "mentions", weight=0.5)
-            for item in _semantic_items(content):
-                semantic_type = item["type"]
-                semantic_title = item["title"]
-                semantic_id = f"{semantic_type.lower()}:{_sha256_text(f'{node_id}:{semantic_type}:{semantic_title}')[:24]}"
+                self._upsert_edge(conn, node_id, chunk_id, "포함함")
+
+            # ── 5. Concept / Feature / Error / Code 노드  (점: 명사) ───────────
+            concept_ids: Dict[str, str] = {}
+            for concept in concepts:
+                node_t = _classify_node_type(concept, content)
+                cid = f"{node_t.lower()}:{_slug(concept)}"
+                concept_ids[concept.lower()] = cid
+                self._upsert_node(
+                    conn, cid, node_t, concept,
+                    metadata={"auto_extracted": True, "source": source},
+                )
+                # 선: Chat이 개념을 "언급함"
+                self._upsert_edge(conn, conv_id, cid, "언급함",
+                                  weight=0.7, metadata={"source": source})
+
+            # ── 6. Concept–Concept 엣지  (선: 동사형) ─────────────────────────
+            for triple in triples:
+                subj_id = concept_ids.get(triple["subject"].lower())
+                obj_id  = concept_ids.get(triple["object"].lower())
+                if subj_id and obj_id and subj_id != obj_id:
+                    self._upsert_edge(
+                        conn, subj_id, obj_id,
+                        triple["relation"],          # 동사형 레이블
+                        weight=1.0,
+                        metadata={"context": triple.get("context", "")[:240]},
+                    )
+
+            # ── 7. Task / Decision 노드  (점: 명사) ────────────────────────────
+            for item in semantic:
+                sem_type  = item["type"]
+                sem_title = item["title"]
+                sem_id = f"{sem_type.lower()}:{_sha256_text(f'{conv_id}:{sem_type}:{sem_title}')[:24]}"
                 self._upsert_node(
-                    conn,
-                    semantic_id,
-                    semantic_type,
-                    semantic_title,
+                    conn, sem_id, sem_type, sem_title,
                     summary=item["summary"],
                     metadata={"auto_extracted": True, "source_node": node_id},
                     raw=item,
                 )
-                self._upsert_edge(conn, node_id, semantic_id, "implies", weight=0.8)
-                if node_type == "AIResponse":
-                    self._upsert_edge(conn, semantic_id, node_id, "based_on", weight=0.6)
+                # 선: Chat이 Task/Decision을 "생성함"
+                self._upsert_edge(conn, conv_id, sem_id, "생성함", weight=0.9)
+                # Task/Decision이 관련 개념을 "언급함"
+                for cid in list(concept_ids.values())[:3]:
+                    self._upsert_edge(conn, sem_id, cid, "언급함", weight=0.6)
+
         return {"node_id": node_id, "type": node_type}
 
     def ingest_document(
@@ -353,43 +650,92 @@ class KnowledgeGraphStore:
             "extracted": {k: v for k, v in (extracted or {}).items() if k != "content"},
             "structure": doc_meta,
         }
+        full_text = f"{filename}\n{text}"
+        concepts = _extract_concepts(full_text, limit=15)
+        triples  = _extract_triples(full_text, concepts)
+
         with self._connect() as conn:
-            self._upsert_node(conn, file_id, "File", filename, summary=(text or filename)[:500], metadata=metadata, raw=metadata)
+            # ── Document 노드  (점: 명사 — 파일) ────────────────────────────────
+            self._upsert_node(
+                conn, file_id, "Document", filename,
+                summary=(text or filename)[:500],
+                metadata=metadata, raw=metadata,
+            )
             self._ingest_structure_nodes(conn, file_id, filename, doc_meta)
+
+            # ── Person 노드 + 동사형 엣지 ─────────────────────────────────────
             if uploader:
                 person_id = f"person:{_slug(uploader)}"
-                self._upsert_node(conn, person_id, "Person", uploader, metadata={"email": uploader})
-                self._upsert_edge(conn, person_id, file_id, "uploaded")
+                self._upsert_node(
+                    conn, person_id, "Person", uploader,
+                    metadata={"email": uploader},
+                )
+                # 선: 동사 — Person이 Document를 "업로드함"
+                self._upsert_edge(conn, person_id, file_id, "업로드함", weight=1.0)
+
+            # ── Chat 노드와 연결 ──────────────────────────────────────────────
             if conversation_id:
                 conv_id = f"conversation:{_slug(conversation_id)}"
-                self._upsert_node(conn, conv_id, "Conversation", conversation_id)
-                self._upsert_edge(conn, conv_id, file_id, "contains")
+                self._upsert_node(conn, conv_id, "Chat", conversation_id)
+                # 선: 동사 — Chat이 Document를 "언급함"
+                self._upsert_edge(conn, conv_id, file_id, "언급함", weight=0.8)
+
+            # ── RAG chunks (검색용, 그래프 비표시) ────────────────────────────
             for index, chunk in enumerate(_chunks(text)):
                 chunk_id = f"chunk:{_sha256_text(f'{file_id}:{index}:{chunk}')[:24]}"
-                self._upsert_node(conn, chunk_id, "Chunk", f"{filename} chunk {index + 1}", summary=chunk[:500], metadata={"index": index, "source_node": file_id})
+                self._upsert_node(
+                    conn, chunk_id, "Chunk",
+                    f"{filename} chunk {index + 1}",
+                    summary=chunk[:500],
+                    metadata={"index": index, "source_node": file_id},
+                )
                 conn.execute(
-                    "INSERT OR REPLACE INTO chunks(id, source_node, text, metadata_json, created_at) VALUES (?, ?, ?, ?, ?)",
-                    (chunk_id, file_id, chunk, _json({"index": index, "source_node": file_id}), _now()),
+                    "INSERT OR REPLACE INTO chunks(id, source_node, text, metadata_json, created_at) "
+                    "VALUES (?, ?, ?, ?, ?)",
+                    (chunk_id, file_id, chunk,
+                     _json({"index": index, "source_node": file_id}), _now()),
                 )
-                self._upsert_edge(conn, file_id, chunk_id, "has_chunk")
-            for topic in _topic_candidates(f"{filename}\n{text}"):
-                topic_id = f"topic:{_slug(topic)}"
-                self._upsert_node(conn, topic_id, "Topic", topic, metadata={"auto_extracted": True})
-                self._upsert_edge(conn, file_id, topic_id, "discusses", weight=0.7)
+                self._upsert_edge(conn, file_id, chunk_id, "포함함")
+
+            # ── Concept / Feature / Error / Code 노드 + 동사형 엣지 ───────────
+            concept_ids: Dict[str, str] = {}
+            for concept in concepts:
+                node_t = _classify_node_type(concept, full_text)
+                cid = f"{node_t.lower()}:{_slug(concept)}"
+                concept_ids[concept.lower()] = cid
+                self._upsert_node(
+                    conn, cid, node_t, concept,
+                    metadata={"auto_extracted": True, "source_file": filename},
+                )
+                # 선: 동사 — Document가 Concept을 "포함함"
+                self._upsert_edge(conn, file_id, cid, "포함함", weight=0.8)
+
+            # ── Concept–Concept 엣지  (선: 동사형) ───────────────────────────
+            for triple in triples:
+                subj_id = concept_ids.get(triple["subject"].lower())
+                obj_id  = concept_ids.get(triple["object"].lower())
+                if subj_id and obj_id and subj_id != obj_id:
+                    self._upsert_edge(
+                        conn, subj_id, obj_id,
+                        triple["relation"],
+                        weight=1.0,
+                        metadata={"context": triple.get("context", "")[:240]},
+                    )
+
+            # ── Task / Decision 노드 ──────────────────────────────────────────
             for item in _semantic_items(text):
-                semantic_type = item["type"]
-                semantic_title = item["title"]
-                semantic_id = f"{semantic_type.lower()}:{_sha256_text(f'{file_id}:{semantic_type}:{semantic_title}')[:24]}"
+                sem_type  = item["type"]
+                sem_title = item["title"]
+                sem_id = f"{sem_type.lower()}:{_sha256_text(f'{file_id}:{sem_type}:{sem_title}')[:24]}"
                 self._upsert_node(
-                    conn,
-                    semantic_id,
-                    semantic_type,
-                    semantic_title,
+                    conn, sem_id, sem_type, sem_title,
                     summary=item["summary"],
                     metadata={"auto_extracted": True, "source_node": file_id, "filename": filename},
                     raw=item,
                 )
-                self._upsert_edge(conn, file_id, semantic_id, "contains_signal", weight=0.8)
+                # 선: Document가 Task/Decision을 "포함함"
+                self._upsert_edge(conn, file_id, sem_id, "포함함", weight=0.9)
+
         return {"node_id": file_id, "sha256": digest, "metadata": metadata}
 
     def ingest_event(
@@ -597,8 +943,23 @@ class KnowledgeGraphStore:
             sheets.append({"title": ws.title, "max_row": ws.max_row, "max_column": ws.max_column})
         return {"sheets": sheets}
 
+    # ── 그래프에 표시되는 노드 타입  (점 = 명사) ──────────────────────────────
+    # Message / AIResponse / Chunk 는 RAG 검색용으로만 저장, 그래프에서 숨김.
+    _GRAPH_VISIBLE_TYPES = (
+        "Chat",       # 대화 세션
+        "Document",   # 파일 (PDF·PPT·Word·Excel·이미지)
+        "Concept",    # 개념 / 아이디어 / 기술 용어
+        "Person",     # 사람
+        "Error",      # 오류 / 버그
+        "Code",       # 코드 / 함수
+        "Feature",    # 소프트웨어 기능
+        "Task",       # 할 일
+        "Decision",   # 결정 사항
+    )
+
     def graph(self, limit: int = 300) -> Dict[str, Any]:
         limit = max(1, min(int(limit or 300), 2000))
+        visible = ",".join(f"'{t}'" for t in self._GRAPH_VISIBLE_TYPES)
         with self._connect() as conn:
             nodes = [
                 {
@@ -610,7 +971,7 @@ class KnowledgeGraphStore:
                     "updated_at": row["updated_at"],
                 }
                 for row in conn.execute(
-                    "SELECT id, type, title, summary, metadata_json, updated_at FROM nodes WHERE type != 'Chunk' ORDER BY updated_at DESC LIMIT ?",
+                    f"SELECT id, type, title, summary, metadata_json, updated_at FROM nodes WHERE type IN ({visible}) ORDER BY updated_at DESC LIMIT ?",
                     (limit,),
                 )
             ]
@@ -618,24 +979,18 @@ class KnowledgeGraphStore:
             edges: List[Dict[str, Any]] = []
             if node_ids:
                 edge_rows = conn.execute(
-                    """
+                    f"""
                     SELECT id, from_node, to_node, type, weight, metadata_json
                     FROM edges
                     WHERE from_node IN (
-                        SELECT id
-                        FROM nodes
-                        WHERE type != 'Chunk'
-                        ORDER BY updated_at DESC
-                        LIMIT ?
+                        SELECT id FROM nodes WHERE type IN ({visible})
+                        ORDER BY updated_at DESC LIMIT ?
                     )
                     AND to_node IN (
-                        SELECT id
-                        FROM nodes
-                        WHERE type != 'Chunk'
-                        ORDER BY updated_at DESC
-                        LIMIT ?
+                        SELECT id FROM nodes WHERE type IN ({visible})
+                        ORDER BY updated_at DESC LIMIT ?
                     )
-                    ORDER BY created_at DESC
+                    ORDER BY weight DESC, created_at DESC
                     """,
                     (limit, limit),
                 ).fetchall()

package/ltcai_cli.py

@@ -248,6 +248,10 @@ def main() -> None:
 
     os.chdir(app_dir)
 
+    # LATTICEAI_TUNNEL=true in .env acts like --tunnel flag
+    if not args.tunnel and os.getenv("LATTICEAI_TUNNEL", "").lower() in ("1", "true", "yes"):
+        args.tunnel = True
+
     # --tunnel forces 0.0.0.0 so cloudflared can reach the server
     if args.tunnel and args.host == "127.0.0.1":
         args.host = "0.0.0.0"
@@ -265,6 +269,21 @@ def main() -> None:
 
     _print_banner(args.host, args.port, tunnel_url)
 
+    # Telegram startup notification (local start, tunnel handled separately inside _start_tunnel)
+    if not args.tunnel:
+        _tg_token = os.getenv("LATTICEAI_TELEGRAM_BOT_TOKEN", "")
+        _tg_chat  = os.getenv("LATTICEAI_TELEGRAM_CHAT_ID", "")
+        if _tg_token and _tg_chat:
+            _local_msg = (
+                f"✅ Lattice AI 시작됨\n\n"
+                f"🏠 로컬: http://localhost:{args.port}"
+            )
+            threading.Thread(
+                target=_send_telegram,
+                args=(_tg_token, _tg_chat, _local_msg),
+                daemon=True,
+            ).start()
+
     import uvicorn
 
     uvicorn.run(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "description": "Lattice AI local MLX/cloud LLM workspace server",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {