ltcai 0.2.1 → 0.3.0

package/latticeai/core/__init__.py

@@ -1 +1 @@
-"""Core utilities: security, sessions, audit."""
+"""Core utilities: security, sessions, audit, context_builder, document_generator."""

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

package/llm_router.py

@@ -329,7 +329,7 @@ class LLMRouter:
             return f"Cached: {cache_key}"
 
         self._enforce_local_model_limit(cache_key)
-        print(f"⏳ Loading Gemma 4 Stack: {cache_key}...")
+        print(f"⏳ Loading local model stack: {cache_key}...")
         loop = asyncio.get_event_loop()
         target_model_id = _resolve_local_hf_model(model_id)
         target_draft_model_id = _resolve_local_hf_model(draft_model_id) if draft_model_id else None
@@ -626,3 +626,150 @@ class LLMRouter:
         except Exception as e:
             print(f"⚠️ VLM image decode failed: {e}")
             return None
+
+    # ── Document Generation Pipeline ──────────────────────────────────────
+
+    async def generate_document(
+        self,
+        message: str,
+        system_prompt: str,
+        *,
+        max_tokens: int = 8192,
+        temperature: float = 0.3,
+    ) -> str:
+        """Generate a document using a specialized system prompt with graph context."""
+        if not self._current:
+            return "No model loaded."
+        self._touch()
+        cached = self._cache[self._current]
+
+        if isinstance(cached, CloudModel):
+            return await self._cloud_generate_document(cached, message, system_prompt, max_tokens, temperature)
+
+        model, tokenizer, draft_model = cached
+        if hasattr(tokenizer, "apply_chat_template"):
+            try:
+                msgs = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": message},
+                ]
+                prompt = tokenizer.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True)
+            except Exception:
+                prompt = f"<|im_start|>system\n{system_prompt}<|im_end|>\n<|im_start|>user\n{message}<|im_end|>\n<|im_start|>assistant\n"
+        else:
+            prompt = f"<|im_start|>system\n{system_prompt}<|im_end|>\n<|im_start|>user\n{message}<|im_end|>\n<|im_start|>assistant\n"
+
+        loop = asyncio.get_event_loop()
+        def _gen():
+            import mlx.core as mx
+            mx.set_default_device(mx.gpu)
+            is_gemma4 = "gemma-4" in self._current.lower() or "gemma4" in self._current.lower()
+            if is_gemma4 and VLM_AVAILABLE:
+                from mlx_vlm import generate as vlm_gen
+                return vlm_gen(model, tokenizer, prompt=prompt, image=None, max_tokens=max_tokens, temp=temperature, draft_model=draft_model, draft_kind="mtp")
+            else:
+                from mlx_lm import generate as lm_gen
+                return lm_gen(model, tokenizer, prompt=prompt, max_tokens=max_tokens, temp=temperature, draft_model=draft_model)
+        result = await loop.run_in_executor(executor, _gen)
+        if hasattr(result, "text"):
+            return normalize_branding(result.text)
+        return normalize_branding(str(result))
+
+    async def _cloud_generate_document(self, cloud: CloudModel, message: str, system_prompt: str, max_tokens: int, temperature: float) -> str:
+        try:
+            response = await cloud.client.chat.completions.create(
+                model=cloud.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": message},
+                ],
+                max_tokens=max_tokens,
+                temperature=temperature,
+            )
+        except Exception as e:
+            raise RuntimeError(self._local_server_error_hint(cloud, e)) from e
+        return normalize_branding(response.choices[0].message.content or "")
+
+    async def stream_generate_document(
+        self,
+        message: str,
+        system_prompt: str,
+        *,
+        max_tokens: int = 8192,
+        temperature: float = 0.3,
+    ) -> AsyncIterator[str]:
+        """Stream document generation with specialized system prompt."""
+        if not self._current:
+            yield "No model loaded."
+            return
+        self._touch()
+        cached = self._cache[self._current]
+
+        if isinstance(cached, CloudModel):
+            async for chunk in self._cloud_stream_document(cached, message, system_prompt, max_tokens, temperature):
+                yield chunk
+            return
+
+        model, tokenizer, draft_model = cached
+        if hasattr(tokenizer, "apply_chat_template"):
+            try:
+                msgs = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": message},
+                ]
+                prompt = tokenizer.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True)
+            except Exception:
+                prompt = f"<|im_start|>system\n{system_prompt}<|im_end|>\n<|im_start|>user\n{message}<|im_end|>\n<|im_start|>assistant\n"
+        else:
+            prompt = f"<|im_start|>system\n{system_prompt}<|im_end|>\n<|im_start|>user\n{message}<|im_end|>\n<|im_start|>assistant\n"
+
+        loop = asyncio.get_event_loop()
+        queue = asyncio.Queue()
+
+        def _stream():
+            import mlx.core as mx
+            mx.set_default_device(mx.gpu)
+            try:
+                is_gemma4 = "gemma-4" in self._current.lower() or "gemma4" in self._current.lower()
+                if is_gemma4 and VLM_AVAILABLE:
+                    from mlx_vlm import stream_generate as vlm_stream
+                    gen = vlm_stream(model, tokenizer, prompt=prompt, image=None, max_tokens=max_tokens, temp=temperature, draft_model=draft_model, draft_kind="mtp")
+                else:
+                    from mlx_lm import stream_generate as lm_stream
+                    gen = lm_stream(model, tokenizer, prompt=prompt, max_tokens=max_tokens, temp=temperature, draft_model=draft_model)
+                for chunk in gen:
+                    text = chunk.text if hasattr(chunk, "text") else (chunk[0] if isinstance(chunk, tuple) else str(chunk))
+                    loop.call_soon_threadsafe(queue.put_nowait, text)
+            except Exception as e:
+                loop.call_soon_threadsafe(queue.put_nowait, f"⚠️ Error: {e}")
+            finally:
+                loop.call_soon_threadsafe(queue.put_nowait, None)
+
+        loop.run_in_executor(executor, _stream)
+        while True:
+            chunk = await queue.get()
+            if chunk is None:
+                break
+            yield normalize_branding(chunk)
+
+    async def _cloud_stream_document(self, cloud: CloudModel, message: str, system_prompt: str, max_tokens: int, temperature: float) -> AsyncIterator[str]:
+        try:
+            stream = await cloud.client.chat.completions.create(
+                model=cloud.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": message},
+                ],
+                max_tokens=max_tokens,
+                temperature=temperature,
+                stream=True,
+            )
+        except Exception as e:
+            yield f"⚠️ {self._local_server_error_hint(cloud, e)}"
+            return
+        async for event in stream:
+            if not event.choices:
+                continue
+            delta = event.choices[0].delta.content
+            if delta:
+                yield normalize_branding(delta)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Lattice AI local MLX/cloud LLM workspace server",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {
@@ -54,7 +54,7 @@
     "tools.py",
     "codex_telegram_bot.py",
     "mcp_registry.py",
-    "latticeai/",
+    "latticeai/**/*.py",
     "skills/",
     "static/account.html",
     "static/chat.html",