siggy-memory 0.5.0__py3-none-any.whl

agents/incident_agent.py

@@ -0,0 +1,90 @@
+import os
+import json
+from groq import Groq
+from dotenv import load_dotenv
+
+from memory.embeddings import get_embedding
+from memory.search import get_search
+from agents.normalizer import normalize_incident, build_embedding_text
+from llm.prompt import build_analyze_prompt, build_search_hint_prompt
+from utils.fallbacks import analyze_incident_fallback
+
+load_dotenv()
+
+_client = None
+
+
+def _get_client():
+    global _client
+    if _client is None:
+        _client = Groq(api_key=os.getenv("GROQ_API_KEY", ""))
+    return _client
+
+
+class IncidentAgent:
+    def __init__(self):
+        self.search = get_search()
+
+    def analyze(self, title: str, summary: str) -> dict:
+        # Step 1: Normalize
+        normalized = normalize_incident(title, summary)
+
+        # Step 2: Embed
+        embedding_text = build_embedding_text(normalized)
+        query_embedding = get_embedding(embedding_text)
+
+        # Step 3: Search with metadata hints
+        hints = build_search_hint_prompt(normalized.model_dump())
+        similar_incidents = self.search.retrieve(
+            query_embedding=query_embedding,
+            top_k=5,
+            filters=hints if hints else None,
+        )
+
+        # Step 4: If metadata filter too strict, fallback to pure vector search
+        if len(similar_incidents) < 2:
+            similar_incidents = self.search.retrieve(
+                query_embedding=query_embedding,
+                top_k=5,
+                filters=None,
+            )
+
+        # Step 5: Build prompt and call LLM
+        prompt = build_analyze_prompt(
+            current_incident={"title": title, "summary": summary},
+            similar_incidents=similar_incidents,
+            normalized=normalized.model_dump(),
+        )
+
+        try:
+            response = _get_client().chat.completions.create(
+                model="llama-3.3-70b-versatile",
+                messages=[
+                    {
+                        "role": "system",
+                        "content": (
+                            "You are a senior SRE engineer. "
+                            "Always return valid JSON. "
+                            "Show your reasoning chain step by step."
+                        ),
+                    },
+                    {"role": "user", "content": prompt},
+                ],
+                temperature=0,
+            )
+
+            raw = response.choices[0].message.content.strip()
+            if raw.startswith("```"):
+                raw = raw.split("\n", 1)[1].rsplit("```", 1)[0].strip()
+
+            analysis = json.loads(raw)
+        except Exception:
+            analysis = analyze_incident_fallback(title, summary, normalized, similar_incidents)
+
+        # Step 6: Build final response
+        return {
+            "current_incident": {"title": title, "summary": summary},
+            "normalized": normalized.model_dump(),
+            "similar_incidents": similar_incidents,
+            "analysis": analysis,
+        }

agents/investigator.py

@@ -0,0 +1,117 @@
+import os
+import json
+import asyncio
+from datetime import datetime, timedelta
+from groq import Groq
+from dotenv import load_dotenv
+
+from telemetry.signoz_mcp import get_telemetry_provider
+from telemetry.summarizer import summarize_telemetry
+from utils.fallbacks import infer_service
+
+load_dotenv()
+
+_client = None
+
+
+def _get_client():
+    global _client
+    if _client is None:
+        _client = Groq(api_key=os.getenv("GROQ_API_KEY", ""))
+    return _client
+
+
+class InvestigatorAgent:
+    def __init__(self):
+        self.telemetry = get_telemetry_provider()
+
+    async def investigate(self, query: str) -> dict:
+        now = datetime.utcnow()
+        start_time = (now - timedelta(hours=1)).isoformat() + "Z"
+        end_time = now.isoformat() + "Z"
+
+        try:
+            services = await self.telemetry.list_services(start_time, end_time)
+        except Exception:
+            services = []
+        relevant_service = self._identify_service(query, services)
+
+        logs_task = self.telemetry.search_logs(
+            service=relevant_service,
+            query="level:error OR level:warn OR timeout OR exception OR error",
+            limit=30,
+            start_time=start_time,
+            end_time=end_time,
+        )
+        traces_task = self.telemetry.search_traces(
+            service=relevant_service,
+            min_duration_ms=1000,
+            limit=20,
+            start_time=start_time,
+            end_time=end_time,
+        )
+        latency_task = self.telemetry.query_metrics(
+            service=relevant_service,
+            metric_name="http_request_duration_milliseconds",
+            aggregation="p99",
+            start_time=start_time,
+            end_time=end_time,
+        )
+        error_task = self.telemetry.query_metrics(
+            service=relevant_service,
+            metric_name="http_requests_total",
+            aggregation="rate",
+            start_time=start_time,
+            end_time=end_time,
+        )
+
+        results = await asyncio.gather(
+            logs_task, traces_task, latency_task, error_task,
+            return_exceptions=True,
+        )
+
+        logs = results[0] if not isinstance(results[0], Exception) else []
+        traces = results[1] if not isinstance(results[1], Exception) else []
+        latency_metric = results[2] if not isinstance(results[2], Exception) else {}
+        error_metric = results[3] if not isinstance(results[3], Exception) else {}
+
+        raw_data = {
+            "query": query,
+            "service": relevant_service,
+            "time_range": {"start": start_time, "end": end_time},
+            "logs": logs,
+            "traces": traces,
+            "latency_metric": latency_metric,
+            "error_metric": error_metric,
+        }
+
+        summary = summarize_telemetry(raw_data)
+        return summary
+
+    def _identify_service(self, query: str, services: list[dict]) -> str:
+        query_lower = query.lower()
+
+        for svc in services:
+            svc_name = svc.get("serviceName", "").lower()
+            if svc_name in query_lower or query_lower in svc_name:
+                return svc.get("serviceName", "unknown")
+
+        if not services:
+            return infer_service(query, "unknown")
+
+        service_names = [s.get("serviceName", "unknown") for s in services]
+        heuristic = infer_service(query, "")
+        if heuristic and any(heuristic == svc.lower() for svc in service_names):
+            return heuristic
+        try:
+            response = _get_client().chat.completions.create(
+                model="llama-3.3-70b-versatile",
+                messages=[
+                    {"role": "system", "content": "You are a service classifier. Return ONLY the service name."},
+                    {"role": "user", "content": f"User query: '{query}'\nAvailable services: {service_names}\nWhich service is the user talking about? Return ONLY the service name."},
+                ],
+                temperature=0,
+            )
+            return response.choices[0].message.content.strip().strip('"').strip("'")
+        except Exception:
+            return service_names[0] if service_names else "unknown"

agents/normalizer.py

@@ -0,0 +1,64 @@
+import os
+import json
+from groq import Groq
+from dotenv import load_dotenv
+
+from models.incident import NormalizedIncident
+from utils.fallbacks import normalize_incident_fallback
+
+load_dotenv()
+
+_client = None
+
+
+def _get_client():
+    global _client
+    if _client is None:
+        _client = Groq(api_key=os.getenv("GROQ_API_KEY", ""))
+    return _client
+
+NORMALIZER_PROMPT = """You are an incident classifier. Convert the raw incident description into a structured JSON object.
+
+Rules:
+- service: the affected service name (lowercase, use "unknown" if unclear)
+- component: the infrastructure component that failed (e.g., redis, kafka, postgresql, cpu, memory, disk, network)
+- failure: the failure type in snake_case (e.g., connection_pool_exhaustion, broker_unavailable, infinite_loop, timeout, memory_leak)
+- symptom: the observable symptom in snake_case (e.g., high_latency, request_timeout, cpu_spike, oom_killed, message_backup)
+- root_cause: one-line technical root cause
+- fix: one-line recommended fix
+
+Return ONLY valid JSON. No markdown, no explanation.
+
+Incident title: {title}
+Incident summary: {summary}"""
+
+
+def normalize_incident(title: str, summary: str) -> NormalizedIncident:
+    try:
+        response = _get_client().chat.completions.create(
+            model="llama-3.3-70b-versatile",
+            messages=[
+                {
+                    "role": "system",
+                    "content": "You are an incident classifier. Return only valid JSON.",
+                },
+                {
+                    "role": "user",
+                    "content": NORMALIZER_PROMPT.format(title=title, summary=summary),
+                },
+            ],
+            temperature=0,
+        )
+
+        raw = response.choices[0].message.content.strip()
+        if raw.startswith("```"):
+            raw = raw.split("\n", 1)[1].rsplit("```", 1)[0].strip()
+
+        data = json.loads(raw)
+        return NormalizedIncident(**data)
+    except Exception:
+        return normalize_incident_fallback(title, summary)
+
+
+def build_embedding_text(normalized: NormalizedIncident) -> str:
+    return f"{normalized.service} {normalized.component} {normalized.failure} {normalized.symptom} {normalized.root_cause}"

agents/recommender.py

@@ -0,0 +1,81 @@
+import os
+import json
+from groq import Groq
+from dotenv import load_dotenv
+
+load_dotenv()
+
+_client = None
+
+
+def _get_client():
+    global _client
+    if _client is None:
+        _client = Groq(api_key=os.getenv("GROQ_API_KEY", ""))
+    return _client
+
+RECOMMENDER_PROMPT = """You are an SRE incident resolution expert. A new incident has occurred. Below are similar incidents from the past with their root causes and fixes.
+
+Use these past incidents to recommend the best fix for the new incident.
+
+IMPORTANT: Return your response as valid JSON with this exact structure:
+{{
+  "recommended_fix": "detailed fix recommendation",
+  "confidence": 0.0 to 1.0,
+  "explanation": "brief explanation of why this fix is recommended"
+}}
+
+--- NEW INCIDENT ---
+Title: {title}
+Summary: {summary}
+Normalized: {normalized}
+
+--- SIMILAR PAST INCIDENTS ---
+{similar_incidents}
+
+--- END ---
+
+Based on the above similar incidents, recommend the best fix for the new incident. Return ONLY valid JSON."""
+
+
+def recommend_fix(
+    title: str,
+    summary: str,
+    normalized: dict,
+    similar_incidents: list[dict],
+) -> dict:
+    incidents_text = ""
+    for i, inc in enumerate(similar_incidents, 1):
+        incidents_text += f"""
+Incident {i}:
+  Title: {inc['title']}
+  Root Cause: {inc['root_cause']}
+  Fix: {inc['fix']}
+  Similarity: {inc['similarity']}
+"""
+
+    response = _get_client().chat.completions.create(
+        model="llama-3.3-70b-versatile",
+        messages=[
+            {
+                "role": "system",
+                "content": "You are an SRE expert. Return only valid JSON.",
+            },
+            {
+                "role": "user",
+                "content": RECOMMENDER_PROMPT.format(
+                    title=title,
+                    summary=summary,
+                    normalized=str(normalized),
+                    similar_incidents=incidents_text.strip(),
+                ),
+            },
+        ],
+        temperature=0,
+    )
+
+    raw = response.choices[0].message.content.strip()
+    if raw.startswith("```"):
+        raw = raw.split("\n", 1)[1].rsplit("```", 1)[0].strip()
+
+    return json.loads(raw)

cli/__init__.py

@@ -0,0 +1 @@
+"""Siggy CLI — production observability with memory."""

cli/__main__.py

@@ -0,0 +1,3 @@
+from cli.main import main
+
+main()

cli/config.py

@@ -0,0 +1,83 @@
+"""Siggy configuration — reads and writes .siggy.yaml."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import yaml
+
+
+CONFIG_FILENAME = ".siggy.yaml"
+
+
+@dataclass
+class SigNozConfig:
+    url: str = "http://localhost:8080"
+    otlp_endpoint: str = "http://localhost:4317"
+    mcp_url: str = "http://localhost:8000/mcp"
+    api_key: str = ""
+    dashboard_url: str = ""
+
+
+@dataclass
+class ServiceConfig:
+    default_name: str = "my-service"
+
+
+@dataclass
+class MemoryConfig:
+    backend_url: str = "http://localhost:8010"
+    qdrant_url: str = "http://localhost:6333"
+
+
+@dataclass
+class SiggyConfig:
+    signoz: SigNozConfig = field(default_factory=SigNozConfig)
+    service: ServiceConfig = field(default_factory=ServiceConfig)
+    memory: MemoryConfig = field(default_factory=MemoryConfig)
+
+    @classmethod
+    def load(cls, path: Path | None = None) -> "SiggyConfig":
+        path = path or _find_config()
+        if path is None:
+            return cls()
+
+        with open(path, encoding="utf-8") as f:
+            raw = yaml.safe_load(f) or {}
+
+        return cls(
+            signoz=SigNozConfig(**raw.get("signoz", {})),
+            service=ServiceConfig(**raw.get("service", {})),
+            memory=MemoryConfig(**raw.get("memory", {})),
+        )
+
+    def save(self, path: Path | None = None) -> Path:
+        path = path or Path.cwd() / CONFIG_FILENAME
+        data = {
+            "signoz": {
+                "url": self.signoz.url,
+                "otlp_endpoint": self.signoz.otlp_endpoint,
+                "mcp_url": self.signoz.mcp_url,
+                "api_key": self.signoz.api_key or os.getenv("SIGNOZ_API_KEY", ""),
+                "dashboard_url": self.signoz.dashboard_url,
+            },
+            "service": {"default_name": self.service.default_name},
+            "memory": {
+                "backend_url": self.memory.backend_url,
+                "qdrant_url": self.memory.qdrant_url,
+            },
+        }
+        with open(path, "w", encoding="utf-8") as f:
+            yaml.dump(data, f, default_flow_style=False, sort_keys=False)
+        return path
+
+
+def _find_config() -> Path | None:
+    current = Path.cwd()
+    for parent in [current, *current.parents]:
+        candidate = parent / CONFIG_FILENAME
+        if candidate.exists():
+            return candidate
+    return None