ltcai 0.2.2 → 0.3.1

package/latticeai/core/context_builder.py

@@ -0,0 +1,191 @@
+"""
+Context Builder — Knowledge Graph 기반 문서 생성용 컨텍스트 조합 모듈.
+
+retrieve_context_for_generation() 파이프라인:
+  Step 1: Query → Hybrid Search (text + graph + recency)
+  Step 2: Seed nodes → Multi-hop traversal (Document → Project → Concept)
+  Step 3: Top-K 결과를 구조화된 Markdown Context로 변환
+"""
+
+import logging
+import re
+from typing import Any, Dict, List, Optional
+
+_CLEAN_RE = re.compile(r"\s+")
+
+
+def _clean(text: str, max_len: int = 700) -> str:
+    return _CLEAN_RE.sub(" ", str(text or "")).strip()[:max_len]
+
+
+def retrieve_context_for_generation(
+    kg_store,
+    query: str,
+    *,
+    max_results: int = 10,
+    max_hops: int = 2,
+) -> Dict[str, Any]:
+    """Knowledge Graph에서 문서 생성에 필요한 컨텍스트를 검색·조합한다.
+
+    Returns:
+        {
+            "query": str,
+            "context_markdown": str,   # LLM 프롬프트에 직접 주입할 Markdown
+            "sources": [...],          # 참조된 소스 목록
+            "stats": {...},            # 검색 통계
+        }
+    """
+    query = str(query or "").strip()
+    if not query or not kg_store:
+        return {"query": query, "context_markdown": "", "sources": [], "stats": {}}
+
+    results = kg_store.search_for_document_generation(query, limit=max_results)
+    if not results:
+        fallback_ctx = kg_store.context_for_query(query, limit=max_results)
+        return {
+            "query": query,
+            "context_markdown": fallback_ctx,
+            "sources": [],
+            "stats": {"method": "fallback", "matches": 0},
+        }
+
+    seed_ids = [r["id"] for r in results]
+    hop_data = kg_store.multi_hop_context(seed_ids, max_hops=max_hops)
+
+    extra_nodes_by_id = {}
+    for node in hop_data.get("nodes", []):
+        if node["id"] not in {r["id"] for r in results}:
+            extra_nodes_by_id[node["id"]] = node
+
+    sections = _build_context_sections(results, extra_nodes_by_id, hop_data.get("edges", []))
+    context_md = _render_markdown(query, sections)
+    sources = _extract_sources(results)
+
+    return {
+        "query": query,
+        "context_markdown": context_md,
+        "sources": sources,
+        "stats": {
+            "method": "hybrid",
+            "primary_matches": len(results),
+            "graph_nodes": len(hop_data.get("nodes", [])),
+            "graph_edges": len(hop_data.get("edges", [])),
+        },
+    }
+
+
+def _build_context_sections(
+    primary_results: List[Dict[str, Any]],
+    extra_nodes: Dict[str, Dict[str, Any]],
+    edges: List[Dict[str, Any]],
+) -> List[Dict[str, Any]]:
+    sections = []
+
+    docs = [r for r in primary_results if r["type"] in (
+        "Document", "File", "SlideDeck", "Spreadsheet", "CodeFile", "Image", "ImageText",
+    )]
+    if docs:
+        sections.append({
+            "title": "관련 문서/파일",
+            "items": docs,
+            "icon": "📄",
+        })
+
+    decisions = [r for r in primary_results if r["type"] in ("Decision", "Task")]
+    if decisions:
+        sections.append({
+            "title": "관련 결정사항/작업",
+            "items": decisions,
+            "icon": "✅",
+        })
+
+    conversations = [r for r in primary_results if r["type"] == "Chat"]
+    if conversations:
+        sections.append({
+            "title": "관련 대화",
+            "items": conversations,
+            "icon": "💬",
+        })
+
+    concepts = [r for r in primary_results if r["type"] in ("Concept", "Feature")]
+    extra_concepts = [n for n in extra_nodes.values() if n["type"] in ("Concept", "Feature")]
+    all_concepts = concepts + extra_concepts[:8]
+    if all_concepts:
+        sections.append({
+            "title": "관련 개념/기술",
+            "items": all_concepts,
+            "icon": "🔗",
+        })
+
+    return sections
+
+
+def _render_markdown(query: str, sections: List[Dict[str, Any]]) -> str:
+    lines = []
+    for section in sections:
+        if not section["items"]:
+            continue
+        lines.append(f"### {section['icon']} {section['title']}")
+        lines.append("")
+        for item in section["items"][:8]:
+            title = item.get("title", "")
+            summary = _clean(item.get("summary", ""))
+            item_type = item.get("type", "")
+            score_info = ""
+            if "hybrid_score" in item:
+                score_info = f" (relevance: {item['hybrid_score']:.2f})"
+
+            meta = item.get("metadata") or {}
+            source = (
+                meta.get("relative_path")
+                or meta.get("filename")
+                or meta.get("conversation_id")
+                or meta.get("source")
+                or item.get("id", "")
+            )
+
+            lines.append(f"- **[{item_type}] {title}**{score_info}")
+            if source and source != item.get("id", ""):
+                lines.append(f"  - 출처: {source}")
+            if summary:
+                lines.append(f"  - {summary}")
+
+            related = item.get("related_concepts", [])
+            if related:
+                tags = ", ".join(c["title"] for c in related[:5])
+                lines.append(f"  - 관련: {tags}")
+
+            lines.append("")
+
+    return "\n".join(lines).strip()
+
+
+def _extract_sources(results: List[Dict[str, Any]]) -> List[Dict[str, str]]:
+    sources = []
+    seen = set()
+    for r in results:
+        meta = r.get("metadata") or {}
+        source_key = (
+            meta.get("relative_path")
+            or meta.get("filename")
+            or meta.get("conversation_id")
+            or r.get("id", "")
+        )
+        if source_key and source_key not in seen:
+            seen.add(source_key)
+            sources.append({
+                "id": r.get("id", ""),
+                "type": r.get("type", ""),
+                "title": r.get("title", ""),
+                "source": source_key,
+            })
+    return sources
+
+
+def format_sources_footnote(sources: List[Dict[str, str]]) -> str:
+    if not sources:
+        return ""
+    lines = ["\n---\n**참조된 지식 그래프 노드:**"]
+    for i, src in enumerate(sources[:10], 1):
+        lines.append(f"{i}. [{src['type']}] {src['title']} ({src['source']})")
+    return "\n".join(lines)

package/latticeai/core/document_generator.py

@@ -0,0 +1,103 @@
+"""
+Document Generator — 지식 그래프 기반 고품질 문서 자동 생성 모듈.
+
+사용자가 "Q3 마케팅 전략 보고서 작성해줘" 같은 일반 채팅을 하면,
+Knowledge Graph에서 관련 과거 문서/개념/관계를 자동으로 찾아
+LLM이 자연스럽고 일관성 있게 새로운 문서를 생성한다.
+"""
+
+import re
+from typing import Optional
+
+_DOCUMENT_INTENT_PATTERNS = [
+    re.compile(r"(보고서|계획서|기획서|제안서|문서|리포트|요약서|분석서|전략서|매뉴얼|가이드)", re.IGNORECASE),
+    re.compile(r"(작성|만들어|생성|써|줘|write|create|generate|draft|compose|prepare)", re.IGNORECASE),
+    re.compile(r"(report|proposal|plan|document|summary|analysis|strategy|guide|manual|brief)", re.IGNORECASE),
+]
+
+_STRONG_INTENT_PATTERNS = [
+    re.compile(r"(작성해|만들어\s*줘|써\s*줘|생성해|write\s+(?:a|me|the)|create\s+(?:a|me|the)|draft\s+(?:a|me|the))", re.IGNORECASE),
+    re.compile(r"(보고서|계획서|기획서|제안서|전략서|매뉴얼).*(작성|만들|생성|써)", re.IGNORECASE),
+    re.compile(r"(작성|만들|생성|써).*(보고서|계획서|기획서|제안서|전략서|매뉴얼)", re.IGNORECASE),
+]
+
+
+def detect_document_intent(message: str) -> bool:
+    """Detect whether the user's message is requesting document generation."""
+    if not message or len(message) < 5:
+        return False
+    for pattern in _STRONG_INTENT_PATTERNS:
+        if pattern.search(message):
+            return True
+    hit_count = sum(1 for p in _DOCUMENT_INTENT_PATTERNS if p.search(message))
+    return hit_count >= 2
+
+
+DOCUMENT_GENERATION_SYSTEM_PROMPT = """당신은 사용자의 개인 AI 지식 어시스턴트 Lattice AI입니다.
+사용자의 기존 지식 기반을 활용하여 고품질 문서를 생성합니다.
+
+## 지침
+1. 아래 제공된 지식 그래프 컨텍스트를 최대한 활용하세요.
+2. 이전 문서의 스타일과 톤을 유지하면서 최신적이고 전문적인 문서를 작성하세요.
+3. 출처는 자연스럽게 본문이나 각주에 포함하세요.
+4. 사용자의 언어(한국어/영어)에 맞춰 작성하세요.
+5. 구조화된 포맷(제목, 소제목, 목록 등)을 사용하세요.
+
+## 사용자의 지식 기반
+
+{graph_context}"""
+
+DOCUMENT_GENERATION_FOLLOWUP_PROMPT = """당신은 사용자의 개인 AI 지식 어시스턴트 Lattice AI입니다.
+이전에 생성한 문서를 사용자의 요청에 따라 수정/보완합니다.
+
+## 이전 생성 컨텍스트
+
+{graph_context}
+
+## 이전 문서
+{previous_document}
+
+위 문서를 사용자의 요청에 따라 수정하세요. 기존 스타일과 톤을 유지하세요."""
+
+
+def build_document_system_prompt(graph_context: str) -> str:
+    if not graph_context:
+        return DOCUMENT_GENERATION_SYSTEM_PROMPT.replace("{graph_context}", "(사용 가능한 지식 기반이 없습니다. 일반 지식을 활용하여 작성합니다.)")
+    return DOCUMENT_GENERATION_SYSTEM_PROMPT.replace("{graph_context}", graph_context)
+
+
+def build_followup_system_prompt(graph_context: str, previous_document: str) -> str:
+    prompt = DOCUMENT_GENERATION_FOLLOWUP_PROMPT.replace("{graph_context}", graph_context or "(없음)")
+    return prompt.replace("{previous_document}", previous_document or "(없음)")
+
+
+class DocumentGenerationSession:
+    """Maintains state across iterative document generation requests."""
+
+    def __init__(self):
+        self._last_context: Optional[str] = None
+        self._last_document: Optional[str] = None
+        self._conversation_id: Optional[str] = None
+
+    @property
+    def has_previous(self) -> bool:
+        return self._last_document is not None
+
+    def update(self, context: str, document: str, conversation_id: Optional[str] = None) -> None:
+        self._last_context = context
+        self._last_document = document
+        if conversation_id:
+            self._conversation_id = conversation_id
+
+    def get_system_prompt(self, graph_context: str) -> str:
+        if self.has_previous:
+            return build_followup_system_prompt(
+                graph_context or self._last_context or "",
+                self._last_document or "",
+            )
+        return build_document_system_prompt(graph_context)
+
+    def clear(self) -> None:
+        self._last_context = None
+        self._last_document = None
+        self._conversation_id = None