use preciz SDK from pip package instead of local path

- Import _call_llm, _parse_tool_calls, execute_tool, _strip_tool_tags
from pip-installed preciz (summarizer.llm_client)
- Remove sys.path.insert hack for local redisum
- Register rag_qa handler in TOOL_HANDLERS at module level
- Add scripts/utils_shim.py + Dockerfile step to work around
missing utils module in preciz pip package
- Update requirements.txt with preciz git dependency
- Fix system prompt to match parser's expected XML format
(name wrapped in <longcat_arg_key>)

Dockerfile

@@ -8,7 +8,10 @@ WORKDIR /app
 
 # Copy requirements and install dependencies
 COPY --chown=user requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
+COPY --chown=user scripts/ scripts/
+RUN pip install --no-cache-dir -r requirements.txt && \
+    python -c "import site; import shutil; shutil.copy('scripts/utils_shim.py', f'{site.getsitepackages()[0]}/utils.py')" && \
+    rm -rf scripts
 
 # Copy application code
 COPY --chown=user app/ app/

app/main.py

@@ -3,138 +3,56 @@ from pydantic import BaseModel
 import os
 import logging
 import sys
+import json
 from dotenv import load_dotenv
 from .config import DATASET_CONFIGS, load_prompt_template
-from openai import OpenAI
-from openai.types.chat import ChatCompletionMessageParam
-import json
-import re
 
-# Load environment variables
 load_dotenv()
 
-def parse_xml_tool_calls(content: str) -> list[dict]:
-    """Parse <longcat_tool_call> XML tags from model output into tool call dicts."""
-    calls = []
-    pattern = r'<longcat_tool_call>\s*(\w+)\s*(.*?)</longcat_tool_call>'
-    for match in re.finditer(pattern, content, re.DOTALL):
-        name = match.group(1)
-        body = match.group(2).strip()
-        args = {}
-        pair_pattern = r'<longcat_arg_key>(\w+)</longcat_arg_key>\s*(?:<longcat_arg_value>(.*?)</longcat_arg_value>)?'
-        for pair_match in re.finditer(pair_pattern, body, re.DOTALL):
-            key = pair_match.group(1)
-            value = pair_match.group(2)
-            if value is not None:
-                args[key] = value.strip()
-        calls.append({"name": name, **args})
-    return calls
-
-# Lazy imports to avoid blocking startup
-# from .pipeline import RAGPipeline  # Will import when needed
-# import umap  # Will import when needed for visualization
-# import plotly.express as px  # Will import when needed for visualization
-# import plotly.graph_objects as go  # Will import when needed for visualization
-# from plotly.subplots import make_subplots  # Will import when needed for visualization
-# import numpy as np  # Will import when needed for visualization
-# from sklearn.preprocessing import normalize  # Will import when needed for visualization
-# import pandas as pd  # Will import when needed for visualization
+from summarizer.llm_client import _call_llm, _parse_tool_calls, _strip_tool_tags, TOOL_HANDLERS, execute_tool
 
-# Configure logging
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.StreamHandler(sys.stdout)
-    ]
+    handlers=[logging.StreamHandler(sys.stdout)]
 )
 logger = logging.getLogger(__name__)
 
 app = FastAPI(title="RAG Pipeline API", description="Multi-dataset RAG API", version="1.0.0")
 
-# Initialize OpenRouter client
-openrouter_api_key = os.getenv("OPENROUTER_API_KEY")
-if not openrouter_api_key:
-    raise ValueError("OPENROUTER_API_KEY environment variable is not set")
-
-openrouter_client = OpenAI(
-    base_url="https://openrouter.ai/api/v1",
-    api_key=openrouter_api_key
-)
-
-# Model configuration
 MODEL_NAME = os.getenv("MODEL_NAME", "openrouter/owl-alpha")
+MAX_ROUNDS = 6
 
-# Initialize pipelines for all datasets
 pipelines = {}
 
-logger.info(f"Starting RAG Pipeline API")
-logger.info(f"Port from env: {os.getenv('PORT', 'Not set - will use 8000')}")
+logger.info(f"Starting RAG Pipeline API — model: {MODEL_NAME}")
 logger.info(f"Available datasets: {list(DATASET_CONFIGS.keys())}")
 
-# Define tools for the GLM model
 def rag_qa(question: str, dataset: str = "developer-portfolio") -> str:
-    """
-    Get answers from the RAG pipeline for specific questions about the dataset.
-    
-    Args:
-        question: The question to answer using the RAG pipeline
-        dataset: The dataset to search in (default: developer-portfolio)
-    
-    Returns:
-        Answer from the RAG pipeline
-    """
     try:
-        # Check if pipelines are loaded
         if not pipelines:
-            return "RAG Pipeline is running but datasets are still loading in the background. Please try again in a moment."
-        
-        # Select the appropriate pipeline based on dataset
+            return "RAG Pipeline is running but datasets are still loading. Please try again in a moment."
         if dataset not in pipelines:
             return f"Dataset '{dataset}' not available. Available datasets: {list(pipelines.keys())}"
-        
-        selected_pipeline = pipelines[dataset]
-        answer = selected_pipeline.answer_question(question)
-        return answer
+        return pipelines[dataset].answer_question(question)
     except Exception as e:
         return f"Error accessing RAG pipeline: {str(e)}"
 
-# Tool definitions for GLM
-TOOLS = [
-    {
-        "type": "function",
-        "function": {
-            "name": "rag_qa",
-            "description": "Get answers from the RAG pipeline for specific questions about datasets",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "question": {
-                        "type": "string",
-                        "description": "The question to answer using the RAG pipeline"
-                    },
-                    "dataset": {
-                        "type": "string",
-                        "description": "The dataset to search in (default: developer-portfolio)",
-                        "default": "developer-portfolio"
-                    }
-                },
-                "required": ["question"]
-            }
-        }
-    }
-]
-
-# Don't load datasets during startup - do it asynchronously after server starts
-logger.info("RAG Pipeline API is ready to serve requests - datasets will load in background")
+def handle_rag_qa_tool(tool_input: str, user_id: str | None = None) -> str:
+    try:
+        args = json.loads(tool_input)
+        return rag_qa(args.get("question", ""), args.get("dataset", "developer-portfolio"))
+    except json.JSONDecodeError:
+        parts = tool_input.split(":", 1)
+        if len(parts) == 2:
+            return rag_qa(parts[1].strip(), parts[0].strip())
+        return rag_qa(tool_input.strip())
 
-# Visualization function disabled to speed up startup
-# def create_3d_visualization(pipeline):
-#     ... (commented out for faster startup)
+TOOL_HANDLERS["rag_qa"] = handle_rag_qa_tool
 
 class Question(BaseModel):
     text: str
-    dataset: str = "developer-portfolio"  # Default dataset
+    dataset: str = "developer-portfolio"
 
 class ChatMessage(BaseModel):
     role: str
@@ -142,151 +60,56 @@ class ChatMessage(BaseModel):
 
 class ChatRequest(BaseModel):
     messages: list[ChatMessage]
-    dataset: str = "developer-portfolio"  # Default dataset
+    dataset: str = "developer-portfolio"
 
 @app.post("/chat")
 async def chat_with_ai(request: ChatRequest):
-    """
-    Chat with the AI assistant. The AI will use the RAG pipeline when needed to answer questions about the datasets.
-    """
-    try:
-        # Convert messages to OpenAI format with proper typing
-        messages: list[ChatCompletionMessageParam] = [
-            {"role": msg.role, "content": msg.content}  # type: ignore
-            for msg in request.messages
-        ]
-        
-        # Add system message to guide the AI
-        if request.dataset == "developer-portfolio":
-            system_message: ChatCompletionMessageParam = {
-                "role": "system",
-                "content": load_prompt_template("system-instruction.txt")
-            }
-        else:
-            system_message: ChatCompletionMessageParam = {
-                "role": "system",
-                "content": load_prompt_template("generic-system-instruction.txt")
-            }
-        messages.insert(0, system_message)
-        
-        # Make the API call with tools
-        response = openrouter_client.chat.completions.create(
-            model=MODEL_NAME,
-            messages=messages,
-            tools=TOOLS,  # type: ignore
-            tool_choice="auto"
-        )
-        
-        message = response.choices[0].message
-        finish_reason = response.choices[0].finish_reason
-        content = message.content or ""
-        
-        # Check for native tool calls or XML-style tool calls in text
-        xml_tool_calls = parse_xml_tool_calls(content)
-        has_native_tool_calls = finish_reason == "tool_calls" and hasattr(message, 'tool_calls') and message.tool_calls
-        
-        if has_native_tool_calls or xml_tool_calls:
-            tool_results = []
-            
-            if has_native_tool_calls:
-                for tool_call in message.tool_calls:
-                    if tool_call.function and tool_call.function.name == "rag_qa":
-                        args = json.loads(tool_call.function.arguments or "{}")
-                        question = args.get("question")
-                        dataset = args.get("dataset", request.dataset)
-                        result = rag_qa(question, dataset)
-                        tool_results.append({"result": result, "native": True})
-                
-                assistant_message: ChatCompletionMessageParam = {
-                    "role": "assistant",
-                    "content": content,
-                    "tool_calls": [
-                        {
-                            "id": tc.id,
-                            "type": tc.type,
-                            "function": {
-                                "name": tc.function.name,
-                                "arguments": tc.function.arguments
-                            }
-                        }
-                        for tc in message.tool_calls
-                        if tc.function
-                    ]
-                }
-                messages.append(assistant_message)
-                
-                for tr in tool_results:
-                    messages.append({
-                        "role": "tool",
-                        "tool_call_id": "call_1",
-                        "content": tr["result"]
-                    })
-            
-            if xml_tool_calls:
-                clean_content = re.sub(r'<longcat_tool_call>.*?</longcat_tool_call>', '', content, flags=re.DOTALL).strip()
-                for tc in xml_tool_calls:
-                    if tc["name"] == "rag_qa":
-                        result = rag_qa(tc.get("question", ""), tc.get("dataset", request.dataset))
-                        tool_results.append({"result": result, "native": False})
-                
-                messages.append({
-                    "role": "assistant",
-                    "content": clean_content or "Let me look that up..."
-                })
-                
-                rag_summary = "\n\n".join([tr["result"] for tr in tool_results])
-                messages.append({
-                    "role": "user",
-                    "content": f"Here is the retrieved information:\n{rag_summary}\n\nNow provide a helpful answer based on this information."
-                })
-            
-            final_response = openrouter_client.chat.completions.create(
-                model=MODEL_NAME,
-                messages=messages
-            )
-            
-            return {
-                "response": final_response.choices[0].message.content,
-                "tool_calls": xml_tool_calls or [
-                    {
-                        "name": tc.function.name,
-                        "arguments": tc.function.arguments
-                    }
-                    for tc in message.tool_calls
-                ] if has_native_tool_calls else None
-            }
-        else:
-            return {
-                "response": content,
-                "tool_calls": None
-            }
-            
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+    messages = [{"role": m.role, "content": m.content} for m in request.messages]
+
+    if request.dataset == "developer-portfolio":
+        system = {"role": "system", "content": load_prompt_template("system-instruction.txt")}
+    else:
+        system = {"role": "system", "content": load_prompt_template("generic-system-instruction.txt")}
+    messages.insert(0, system)
+
+    for _ in range(MAX_ROUNDS):
+        content = _call_llm(messages, model=MODEL_NAME, max_tokens=4000)
+
+        tool_calls = _parse_tool_calls(content)
+        if not tool_calls:
+            clean = _strip_tool_tags(content)
+            return {"response": clean if clean else content, "tool_calls": None}
+
+        clean_content = _strip_tool_tags(content)
+        messages.append({"role": "assistant", "content": clean_content or "Let me check that..."})
+
+        results = []
+        for name, inp in tool_calls:
+            result = execute_tool(name, inp)
+            results.append(result)
+
+        for result in results:
+            messages.append({"role": "user", "content": f"RAG result:\n{result}\n\nNow answer based on this."})
 
-# /answer endpoint removed - use /chat for all interactions
+    content = _call_llm(messages, model=MODEL_NAME, max_tokens=4000)
+    clean = _strip_tool_tags(content)
+    return {"response": clean if clean else content, "tool_calls": None}
 
 @app.get("/datasets")
 async def list_datasets():
-    """List all available datasets"""
     return {"datasets": list(pipelines.keys())}
 
 @app.get("/questions")
 async def list_questions(dataset: str = "developer-portfolio"):
-    """List all questions for a given dataset"""
     if dataset not in pipelines:
         raise HTTPException(status_code=400, detail=f"Dataset '{dataset}' not available. Available datasets: {list(pipelines.keys())}")
-    
     selected_pipeline = pipelines[dataset]
     questions = [doc.meta['question'] for doc in selected_pipeline.documents if 'question' in doc.meta]
     return {"dataset": dataset, "questions": questions}
 
 async def load_datasets_background():
-    """Load datasets in background after server starts"""
     global pipelines
-    # Import RAGPipeline only when needed
     from .pipeline import RAGPipeline
-    # Only load developer-portfolio to save memory
     dataset_name = "developer-portfolio"
     try:
         logger.info(f"Loading dataset: {dataset_name}")
@@ -295,14 +118,11 @@ async def load_datasets_background():
         logger.info(f"Successfully loaded {dataset_name}")
     except Exception as e:
         logger.error(f"Failed to load {dataset_name}: {e}")
-    logger.info(f"Background loading complete - {len(pipelines)} datasets loaded")
+    logger.info(f"Background loading complete — {len(pipelines)} datasets loaded")
 
 @app.on_event("startup")
 async def startup_event():
     logger.info("FastAPI application startup complete")
-    logger.info(f"Server should be running on port: {os.getenv('PORT', '8000')}")
-    
-    # Start loading datasets in background (non-blocking)
     import asyncio
     asyncio.create_task(load_datasets_background())
 
@@ -312,18 +132,15 @@ async def shutdown_event():
 
 @app.get("/")
 async def root():
-    """Root endpoint"""
     return {"status": "ok", "message": "RAG Pipeline API", "version": "1.0.0", "datasets": list(pipelines.keys())}
 
 @app.get("/health")
 async def health_check():
-    """Health check endpoint"""
-    logger.info("Health check called")
     loading_status = "complete" if "developer-portfolio" in pipelines else "loading"
     return {
-        "status": "healthy", 
-        "datasets_loaded": len(pipelines), 
-        "total_datasets": 1,  # Only loading developer-portfolio
+        "status": "healthy",
+        "datasets_loaded": len(pipelines),
+        "total_datasets": 1,
         "loading_status": loading_status,
-        "port": os.getenv('PORT', '8000')
+        "port": os.getenv("PORT", "8000"),
     }

prompts/system-instruction.txt

@@ -13,8 +13,12 @@ When you use rag_qa tool, you MUST use retrieved information to answer about the
 - 📝 Format responses with markdown for readability
 
 ## 🛠 Tool Calling Format
-If you don't support native function calling, use this XML format to call the rag_qa tool:
-<longcat_tool_call>rag_qa <longcat_arg_key>question</longcat_arg_key> <longcat_arg_value>your question here</longcat_arg_value> <longcat_arg_key>dataset</longcat_arg_key> <longcat_arg_value>developer-portfolio</longcat_arg_value> </longcat_tool_call>
+Use the rag_qa tool to retrieve information when needed. Output the tool call in this exact XML format — each piece on its own line, with `name` wrapped in `<longcat_arg_key>`:
+<longcat_tool_call>
+<longcat_arg_key>name</longcat_arg_key><longcat_arg_value>rag_qa</longcat_arg_value>
+<longcat_arg_key>question</longcat_arg_key><longcat_arg_value>your question here</longcat_arg_value>
+<longcat_arg_key>dataset</longcat_arg_key><longcat_arg_value>developer-portfolio</longcat_arg_value>
+</longcat_tool_call>
 
 ## ✅ Examples:
 ❌ **Wrong:** "I am a Tech Lead at FleetEnable"

requirements.txt

@@ -3,8 +3,9 @@ datasets==3.3.2
 onnxruntime==1.20.1
 transformers==4.46.3
 huggingface-hub>=0.24.0
-fastapi==0.115.4
-uvicorn==0.31.0
-openai==1.57.0
-python-dotenv==1.0.1
-pydantic==2.10.4
+fastapi>=0.115.4
+uvicorn>=0.31.0
+openai>=1.57.0
+python-dotenv>=1.0.1
+pydantic>=2.10.4
+preciz @ git+https://github.com/syntaxhacker/preciz-agent.git@cli-sdk

scripts/utils_shim.py

@@ -0,0 +1,38 @@
+import os, json, tempfile
+
+_DATA_DIR = os.environ.get("PRECIZ_DATA_DIR", "/tmp")
+
+
+def _data_dir(username=None):
+    d = _DATA_DIR
+    if username:
+        d = os.path.join(d, username)
+    return d
+
+
+def load_memory():
+    p = os.path.join(_data_dir(), "memory", "memory.json")
+    os.makedirs(os.path.dirname(p), exist_ok=True)
+    if not os.path.exists(p):
+        return {"ttl_days": 7, "model_cache": {}}
+    try:
+        with open(p) as f:
+            return json.load(f)
+    except json.JSONDecodeError:
+        return {"ttl_days": 7, "model_cache": {}}
+
+
+def save_memory(memory):
+    p = os.path.join(_data_dir(), "memory", "memory.json")
+    os.makedirs(os.path.dirname(p), exist_ok=True)
+    fd, tmp = tempfile.mkstemp(dir=os.path.dirname(p), suffix=".json")
+    try:
+        with os.fdopen(fd, "w") as f:
+            json.dump(memory, f, indent=2)
+        os.replace(tmp, p)
+    except Exception:
+        try:
+            os.unlink(tmp)
+        except Exception:
+            pass
+        raise