ltcai 0.2.2 → 0.3.0

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

@@ -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.2",
+  "version": "0.3.0",
   "description": "Lattice AI local MLX/cloud LLM workspace server",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {

package/server.py

@@ -46,8 +46,10 @@ from pydantic import BaseModel
 from PIL import Image
 
 from llm_router import AsyncOpenAI, LLMRouter, OPENAI_COMPATIBLE_PROVIDERS, HF_MODELS_ROOT, ensure_mlx_runtime, hf_model_dir, parse_model_ref, mx, normalize_branding
-from knowledge_graph import KnowledgeGraphStore
+from knowledge_graph import KnowledgeGraphStore, set_llm_router
 from knowledge_graph_api import create_knowledge_graph_router
+from latticeai.core.context_builder import retrieve_context_for_generation, format_sources_footnote
+from latticeai.core.document_generator import detect_document_intent, DocumentGenerationSession
 from local_knowledge_api import LocalKnowledgeWatcher, create_local_knowledge_router
 from latticeai.core.security import (
     hash_password as _hash_password,
@@ -1001,7 +1003,9 @@ def build_admin_audit_report(users: Dict) -> Dict:
     )
 
 router = LLMRouter()
+set_llm_router(router)
 gardener = PReinforceGardener()
+_doc_gen_sessions: dict = {}  # conversation_id → DocumentGenerationSession
 
 async def autoload_default_model() -> None:
     if not AUTOLOAD_MODELS:
@@ -3636,12 +3640,24 @@ async def chat(req: ChatRequest, request: Request):
     except Exception as e:
         logging.warning("Knowledge reinforcement skipped: %s", e)
 
+    is_doc_gen = detect_document_intent(req.message)
+    doc_gen_context_result = None
+
     try:
         if ENABLE_GRAPH and KNOWLEDGE_GRAPH:
-            graph_context = KNOWLEDGE_GRAPH.context_for_query(req.message)
-            if graph_context:
-                context += f"\n\n[KNOWLEDGE GRAPH]\n{graph_context}"
-                print("🕸️ Context reinforced with knowledge graph.")
+            if is_doc_gen:
+                doc_gen_context_result = retrieve_context_for_generation(
+                    KNOWLEDGE_GRAPH, req.message, max_results=10, max_hops=2,
+                )
+                graph_md = doc_gen_context_result.get("context_markdown", "")
+                if graph_md:
+                    context += f"\n\n[KNOWLEDGE GRAPH — Document Generation Context]\n{graph_md}"
+                    print("📝 Document generation context retrieved from knowledge graph.")
+            else:
+                graph_context = KNOWLEDGE_GRAPH.context_for_query(req.message)
+                if graph_context:
+                    context += f"\n\n[KNOWLEDGE GRAPH]\n{graph_context}"
+                    print("🕸️ Context reinforced with knowledge graph.")
     except Exception as e:
         logging.warning("Knowledge graph reinforcement skipped: %s", e)
 
@@ -3651,7 +3667,6 @@ async def chat(req: ChatRequest, request: Request):
             context += f"\n\n{screenshot_context}"
 
     if env_bool("LATTICEAI_AUTO_READ_CHAT_PATHS", default=False):
-        # Off by default: automatic local-file injection can leak files to cloud models.
         _file_path_re = re.compile(r'(?:^|[\s\'\"(])((~|/[\w.])[^\s\'")\]]*)', re.MULTILINE)
         for _m in _file_path_re.finditer(req.message or ""):
             _fpath = _m.group(1).strip()
@@ -3669,6 +3684,55 @@ async def chat(req: ChatRequest, request: Request):
     if req.source != "telegram":
         asyncio.create_task(broadcast_web_chat("user", req.message))
 
+    if is_doc_gen and ENABLE_GRAPH and KNOWLEDGE_GRAPH:
+        conv_key = req.conversation_id or "default"
+        session = _doc_gen_sessions.get(conv_key)
+        if session is None:
+            session = DocumentGenerationSession()
+            _doc_gen_sessions[conv_key] = session
+        graph_md = (doc_gen_context_result or {}).get("context_markdown", "")
+        system_prompt = session.get_system_prompt(graph_md)
+        sources = (doc_gen_context_result or {}).get("sources", [])
+        footnote = format_sources_footnote(sources)
+
+        if req.stream:
+            async def _stream_doc_gen():
+                collected = []
+                async for chunk in router.stream_generate_document(
+                    req.message, system_prompt,
+                    max_tokens=req.max_tokens or 8192,
+                    temperature=req.temperature or 0.3,
+                ):
+                    collected.append(chunk)
+                    yield f"data: {json.dumps({'text': chunk}, ensure_ascii=False)}\n\n"
+                full_text = "".join(collected)
+                if footnote:
+                    yield f"data: {json.dumps({'text': footnote}, ensure_ascii=False)}\n\n"
+                    full_text += footnote
+                session.update(graph_md, full_text, req.conversation_id)
+                save_to_history("assistant", full_text, source=req.source or "web", conversation_id=req.conversation_id, **history_user)
+                if req.source != "telegram":
+                    asyncio.create_task(broadcast_web_chat("assistant", full_text))
+                yield "data: [DONE]\n\n"
+            return StreamingResponse(
+                _stream_doc_gen(),
+                media_type="text/event-stream",
+                headers={"X-Model": router.current_model_id, "X-Doc-Gen": "true"},
+            )
+        else:
+            result = await router.generate_document(
+                req.message, system_prompt,
+                max_tokens=req.max_tokens or 8192,
+                temperature=req.temperature or 0.3,
+            )
+            if footnote:
+                result += footnote
+            session.update(graph_md, result, req.conversation_id)
+            save_to_history("assistant", str(result), source=req.source or "web", conversation_id=req.conversation_id, **history_user)
+            if req.source != "telegram":
+                asyncio.create_task(broadcast_web_chat("assistant", str(result)))
+            return JSONResponse(content={"response": str(result)})
+
     if req.stream:
         recent_context = build_recent_chat_context(user_email=effective_email, conversation_id=req.conversation_id)
         stream_context = context

package/static/css/tokens.css

@@ -159,6 +159,32 @@
   --radius-sm:    var(--lt-radius-sm);
 }
 
+/* ── Global polish ─────────────────────────────────────────── */
+::selection {
+  background: rgba(110, 74, 230, 0.18);
+  color: var(--lt-color-ink-900);
+}
+
+:focus-visible {
+  outline: 2px solid rgba(110, 74, 230, 0.40);
+  outline-offset: 2px;
+}
+
+::-webkit-scrollbar {
+  width: 6px;
+  height: 6px;
+}
+::-webkit-scrollbar-track {
+  background: transparent;
+}
+::-webkit-scrollbar-thumb {
+  background: rgba(110, 74, 230, 0.16);
+  border-radius: 99px;
+}
+::-webkit-scrollbar-thumb:hover {
+  background: rgba(110, 74, 230, 0.28);
+}
+
 /* ── Reduced motion (a11y) ─────────────────────────────────── */
 @media (prefers-reduced-motion: reduce) {
   :root {