nirixa 0.1.0__tar.gz

nirixa-0.1.0/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: nirixa
+Version: 0.1.0
+Summary: AI Observability & Cost Intelligence — track token costs, latency, and hallucination risk
+Home-page: https://nirixa.in
+Author: Nirixa
+Author-email: nirixaai@gmail.com
+Keywords: llm observability openai anthropic groq gemini mistral ollama cost monitoring hallucination
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.20.0; extra == "anthropic"
+Provides-Extra: groq
+Requires-Dist: groq>=0.4.0; extra == "groq"
+Provides-Extra: gemini
+Requires-Dist: google-generativeai>=0.5.0; extra == "gemini"
+Provides-Extra: mistral
+Requires-Dist: mistralai>=1.0.0; extra == "mistral"
+Provides-Extra: together
+Requires-Dist: together>=1.0.0; extra == "together"
+Provides-Extra: ollama
+Requires-Dist: ollama>=0.1.0; extra == "ollama"
+Provides-Extra: all
+Requires-Dist: openai>=1.0.0; extra == "all"
+Requires-Dist: anthropic>=0.20.0; extra == "all"
+Requires-Dist: groq>=0.4.0; extra == "all"
+Requires-Dist: google-generativeai>=0.5.0; extra == "all"
+Requires-Dist: mistralai>=1.0.0; extra == "all"
+Requires-Dist: together>=1.0.0; extra == "all"
+Requires-Dist: ollama>=0.1.0; extra == "all"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# nirixa
+
+**AI Observability & Cost Intelligence** — track token costs, latency, and hallucination risk for every LLM call.
+
+```bash
+pip install nirixa
+```
+
+## Quick Start
+
+```python
+from nirixa import NirixaClient
+import openai
+
+client = NirixaClient(api_key="nirixa-your-key")
+
+# Wrap any LLM call — zero changes to your existing code
+response = client.track(
+    feature="/api/chat",
+    fn=lambda: openai.chat.completions.create(
+        model="gpt-4o",
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+)
+
+# response is the original OpenAI response — unchanged
+print(response.choices[0].message.content)
+```
+
+## Module-level API
+
+```python
+import nirixa
+import openai
+
+nirixa.init(api_key="nirixa-your-key")
+
+response = nirixa.track(
+    feature="/api/summarize",
+    fn=lambda: openai.chat.completions.create(...)
+)
+```
+
+## Auto-patch (track everything automatically)
+
+```python
+from nirixa import NirixaClient
+from nirixa.middleware import patch_openai
+
+client = NirixaClient(api_key="nirixa-your-key")
+patch_openai(client, feature="/api/chat")
+
+# All openai calls now tracked automatically — no changes needed
+import openai
+openai.chat.completions.create(...)
+```
+
+## Anthropic Support
+
+```python
+from nirixa import NirixaClient
+import anthropic
+
+client  = NirixaClient(api_key="nirixa-your-key")
+claude  = anthropic.Anthropic()
+
+response = client.track(
+    feature="/api/analyze",
+    model="claude-3-5-sonnet-20241022",
+    fn=lambda: claude.messages.create(
+        model="claude-3-5-sonnet-20241022",
+        max_tokens=1024,
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+)
+```
+
+## What gets tracked
+
+| Metric | Description |
+|--------|-------------|
+| Token cost | Per-call USD cost by feature and model |
+| Latency | p50/p95/p99 response times |
+| Hallucination risk | LOW / MEDIUM / HIGH scoring |
+| Prompt drift | Output variance over time |
+| Error rate | Failed calls by endpoint |
+
+## Dashboard
+
+View all your data at [nirixa.in](https://nirixa.in)
+
+---
+निरीक्षा — Observe everything.

nirixa-0.1.0/README.md

@@ -0,0 +1,93 @@
+# nirixa
+
+**AI Observability & Cost Intelligence** — track token costs, latency, and hallucination risk for every LLM call.
+
+```bash
+pip install nirixa
+```
+
+## Quick Start
+
+```python
+from nirixa import NirixaClient
+import openai
+
+client = NirixaClient(api_key="nirixa-your-key")
+
+# Wrap any LLM call — zero changes to your existing code
+response = client.track(
+    feature="/api/chat",
+    fn=lambda: openai.chat.completions.create(
+        model="gpt-4o",
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+)
+
+# response is the original OpenAI response — unchanged
+print(response.choices[0].message.content)
+```
+
+## Module-level API
+
+```python
+import nirixa
+import openai
+
+nirixa.init(api_key="nirixa-your-key")
+
+response = nirixa.track(
+    feature="/api/summarize",
+    fn=lambda: openai.chat.completions.create(...)
+)
+```
+
+## Auto-patch (track everything automatically)
+
+```python
+from nirixa import NirixaClient
+from nirixa.middleware import patch_openai
+
+client = NirixaClient(api_key="nirixa-your-key")
+patch_openai(client, feature="/api/chat")
+
+# All openai calls now tracked automatically — no changes needed
+import openai
+openai.chat.completions.create(...)
+```
+
+## Anthropic Support
+
+```python
+from nirixa import NirixaClient
+import anthropic
+
+client  = NirixaClient(api_key="nirixa-your-key")
+claude  = anthropic.Anthropic()
+
+response = client.track(
+    feature="/api/analyze",
+    model="claude-3-5-sonnet-20241022",
+    fn=lambda: claude.messages.create(
+        model="claude-3-5-sonnet-20241022",
+        max_tokens=1024,
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+)
+```
+
+## What gets tracked
+
+| Metric | Description |
+|--------|-------------|
+| Token cost | Per-call USD cost by feature and model |
+| Latency | p50/p95/p99 response times |
+| Hallucination risk | LOW / MEDIUM / HIGH scoring |
+| Prompt drift | Output variance over time |
+| Error rate | Failed calls by endpoint |
+
+## Dashboard
+
+View all your data at [nirixa.in](https://nirixa.in)
+
+---
+निरीक्षा — Observe everything.

nirixa-0.1.0/nirixa/__init__.py

@@ -0,0 +1,40 @@
+# nirixa/__init__.py
+
+from .client import NirixaClient
+
+__version__ = "0.1.0"
+__all__ = ["NirixaClient", "track"]
+
+# Module-level singleton — optional convenience API
+_client: NirixaClient | None = None
+
+
+def init(api_key: str, host: str = "https://api.nirixa.in", **kwargs):
+    """
+    Initialize module-level client for simple usage.
+
+    Usage:
+        import nirixa
+        nirixa.init(api_key="nirixa-xxx")
+        nirixa.track(feature="/api/chat", fn=lambda: openai.chat.completions.create(...))
+    """
+    global _client
+    _client = NirixaClient(api_key=api_key, host=host, **kwargs)
+    return _client
+
+
+def track(feature: str, fn, **kwargs):
+    """
+    Track an LLM call using the module-level client.
+    Call nirixa.init() first.
+    """
+    if _client is None:
+        raise RuntimeError("Call nirixa.init(api_key='...') before using nirixa.track()")
+    return _client.track(feature=feature, fn=fn, **kwargs)
+
+
+def get_client() -> NirixaClient:
+    """Get the module-level client."""
+    if _client is None:
+        raise RuntimeError("Call nirixa.init(api_key='...') first")
+    return _client

nirixa-0.1.0/nirixa/client.py

@@ -0,0 +1,326 @@
+# nirixa/client.py
+
+import time
+import uuid
+import threading
+import requests
+from typing import Callable, Optional, Any
+from . import scorer as halluc_scorer
+
+
+class NirixaClient:
+    """
+    Main Nirixa client. Track any LLM call with one line.
+
+    Supported providers:
+        - OpenAI       (gpt-4o, gpt-4o-mini, gpt-3.5-turbo, ...)
+        - Anthropic    (claude-3-5-sonnet, claude-3-opus, ...)
+        - Google       (gemini-1.5-pro, gemini-2.0-flash, ...)
+        - Groq         (llama-3.1, mixtral, gemma, ...)
+        - Mistral      (mistral-large, mistral-small, ...)
+        - Together AI  (llama, qwen, deepseek, ...)
+        - Ollama       (llama3, mistral, phi3, local models)
+        - AWS Bedrock  (claude, llama, titan, ...)
+
+    Usage:
+        client = NirixaClient(api_key="nirixa-xxx")
+        result = client.track(
+            feature="/api/chat",
+            fn=lambda: openai.chat.completions.create(...)
+        )
+    """
+
+    def __init__(
+        self,
+        api_key:              str,
+        host:                 str  = "https://api.nirixa.in",
+        score_hallucinations: bool = True,
+        async_ingest:         bool = True,
+        debug:                bool = False,
+    ):
+        self.api_key              = api_key
+        self.host                 = host.rstrip("/")
+        self.score_hallucinations = score_hallucinations
+        self.async_ingest         = async_ingest
+        self.debug                = debug
+        self._session             = requests.Session()
+        self._session.headers.update({
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type":  "application/json",
+            "User-Agent":    "nirixa-python/0.1.0",
+        })
+        self._threads = []
+
+    # ── Public API ────────────────────────────────────────
+
+    def track(
+        self,
+        feature:  str,
+        fn:       Callable,
+        model:    Optional[str] = None,
+        provider: Optional[str] = None,
+        prompt:   Optional[str] = None,
+    ) -> Any:
+        """
+        Wrap any LLM call and track cost, latency, and hallucination risk.
+
+        Args:
+            feature:  Your feature/endpoint name e.g. "/api/summarize"
+            fn:       Lambda or callable that makes the LLM call
+            model:    Model name override (auto-detected for most providers)
+            provider: Provider override ("openai", "anthropic", "google", etc.)
+            prompt:   Optional prompt text for better hallucination scoring
+
+        Returns:
+            The original LLM response unchanged
+        """
+        start     = time.time()
+        error_msg = None
+        response  = None
+
+        try:
+            response = fn()
+        except Exception as e:
+            error_msg = str(e)
+            raise
+        finally:
+            latency_ms = int((time.time() - start) * 1000)
+            meta       = self._extract_meta(response, model, provider)
+
+            halluc = {"score": None, "risk": None}
+            if self.score_hallucinations and response is not None:
+                output_text = self._extract_text(response)
+                if output_text:
+                    halluc = halluc_scorer.score(
+                        output=output_text,
+                        prompt=prompt,
+                        model=meta["model"],
+                    )
+
+            payload = {
+                "call_id":           str(uuid.uuid4()),
+                "provider":          meta["provider"],
+                "model":             meta["model"] or "unknown",
+                "feature":           feature,
+                "prompt_tokens":     meta["prompt_tokens"],
+                "completion_tokens": meta["completion_tokens"],
+                "total_tokens":      meta["total_tokens"],
+                "cost_usd":          meta["cost_usd"],
+                "latency_ms":        latency_ms,
+                "halluc_score":      halluc["score"],
+                "halluc_risk":       halluc["risk"],
+                "error":             error_msg,
+            }
+
+            if self.async_ingest:
+                t = threading.Thread(target=self._ingest, args=(payload,), daemon=True)
+                t.start()
+                self._threads.append(t)
+            else:
+                self._ingest(payload)
+
+        return response
+
+    def flush(self, timeout: float = 5.0):
+        """Wait for all pending ingest threads. Call before script exits."""
+        for t in self._threads:
+            t.join(timeout=timeout)
+        self._threads.clear()
+
+    def health(self) -> bool:
+        """Check if Nirixa backend is reachable."""
+        try:
+            r = self._session.get(f"{self.host}/health", timeout=3)
+            return r.status_code == 200
+        except Exception:
+            return False
+
+    # ── Ingest ────────────────────────────────────────────
+
+    def _ingest(self, payload: dict):
+        try:
+            r = self._session.post(f"{self.host}/ingest", json=payload, timeout=5)
+            if self.debug:
+                print(f"[nirixa] {payload['feature']} → {r.status_code} ({payload['total_tokens']} tokens, ${payload['cost_usd']})")
+        except Exception as e:
+            if self.debug:
+                print(f"[nirixa] ingest failed: {e}")
+
+    # ── Meta Extraction (per provider) ───────────────────
+
+    def _extract_meta(self, response, model_override, provider_override) -> dict:
+        meta = {
+            "model":             model_override,
+            "provider":          provider_override,
+            "prompt_tokens":     0,
+            "completion_tokens": 0,
+            "total_tokens":      0,
+            "cost_usd":          0.0,
+        }
+        if response is None:
+            return meta
+
+        # ── OpenAI & Groq & Together AI & Mistral ──────────
+        # All use OpenAI-compatible response format
+        if hasattr(response, "usage") and hasattr(response, "choices"):
+            usage            = response.usage
+            raw_model        = getattr(response, "model", "") or ""
+            meta["model"]    = model_override or raw_model
+            meta["provider"] = provider_override or self._detect_provider(raw_model)
+
+            if usage:
+                meta["prompt_tokens"]     = getattr(usage, "prompt_tokens", 0) or 0
+                meta["completion_tokens"] = getattr(usage, "completion_tokens", 0) or 0
+                meta["total_tokens"]      = getattr(usage, "total_tokens", 0) or (meta["prompt_tokens"] + meta["completion_tokens"])
+                meta["cost_usd"]          = self._calc_cost(meta["model"], meta["prompt_tokens"], meta["completion_tokens"])
+            return meta
+
+        # ── Anthropic ──────────────────────────────────────
+        if hasattr(response, "usage") and hasattr(response, "content") and not hasattr(response, "choices"):
+            usage            = response.usage
+            raw_model        = getattr(response, "model", "") or ""
+            meta["model"]    = model_override or raw_model
+            meta["provider"] = provider_override or "anthropic"
+
+            if usage:
+                meta["prompt_tokens"]     = getattr(usage, "input_tokens", 0) or 0
+                meta["completion_tokens"] = getattr(usage, "output_tokens", 0) or 0
+                meta["total_tokens"]      = meta["prompt_tokens"] + meta["completion_tokens"]
+                meta["cost_usd"]          = self._calc_cost(meta["model"], meta["prompt_tokens"], meta["completion_tokens"])
+            return meta
+
+        # ── Google Gemini (native SDK) ─────────────────────
+        # response.usage_metadata.prompt_token_count
+        if hasattr(response, "usage_metadata"):
+            um               = response.usage_metadata
+            meta["model"]    = model_override or getattr(response, "model", "gemini")
+            meta["provider"] = provider_override or "google"
+            meta["prompt_tokens"]     = getattr(um, "prompt_token_count", 0) or 0
+            meta["completion_tokens"] = getattr(um, "candidates_token_count", 0) or 0
+            meta["total_tokens"]      = getattr(um, "total_token_count", 0) or (meta["prompt_tokens"] + meta["completion_tokens"])
+            meta["cost_usd"]          = self._calc_cost(meta["model"], meta["prompt_tokens"], meta["completion_tokens"])
+            return meta
+
+        # ── Ollama ─────────────────────────────────────────
+        # response is a dict: {"model": ..., "prompt_eval_count": ..., "eval_count": ...}
+        if isinstance(response, dict) and "prompt_eval_count" in response:
+            meta["model"]             = model_override or response.get("model", "ollama")
+            meta["provider"]          = provider_override or "ollama"
+            meta["prompt_tokens"]     = response.get("prompt_eval_count", 0) or 0
+            meta["completion_tokens"] = response.get("eval_count", 0) or 0
+            meta["total_tokens"]      = meta["prompt_tokens"] + meta["completion_tokens"]
+            meta["cost_usd"]          = 0.0  # local models = free
+            return meta
+
+        # ── AWS Bedrock ────────────────────────────────────
+        # response["ResponseMetadata"] or response.get("usage")
+        if isinstance(response, dict) and "ResponseMetadata" in response:
+            meta["provider"] = provider_override or "bedrock"
+            body             = response.get("body", {})
+            if isinstance(body, dict):
+                usage                     = body.get("usage", {})
+                meta["model"]             = model_override or response.get("model", "bedrock")
+                meta["prompt_tokens"]     = usage.get("input_tokens", 0) or 0
+                meta["completion_tokens"] = usage.get("output_tokens", 0) or 0
+                meta["total_tokens"]      = meta["prompt_tokens"] + meta["completion_tokens"]
+                meta["cost_usd"]          = self._calc_cost(meta["model"], meta["prompt_tokens"], meta["completion_tokens"])
+            return meta
+
+        return meta
+
+    def _detect_provider(self, model: str) -> str:
+        """Auto-detect provider from model name."""
+        m = model.lower()
+        if any(x in m for x in ["gpt", "o1", "o3", "text-davinci"]):
+            return "openai"
+        if any(x in m for x in ["claude"]):
+            return "anthropic"
+        if any(x in m for x in ["gemini"]):
+            return "google"
+        if any(x in m for x in ["llama", "mixtral", "gemma", "whisper"]):
+            # Could be Groq, Together, or Ollama — default groq for API calls
+            return "groq"
+        if any(x in m for x in ["mistral", "codestral"]):
+            return "mistral"
+        if any(x in m for x in ["qwen", "deepseek", "falcon"]):
+            return "together"
+        return "unknown"
+
+    def _extract_text(self, response) -> Optional[str]:
+        """Extract text output for hallucination scoring."""
+        try:
+            # OpenAI / Groq / Together / Mistral
+            if hasattr(response, "choices"):
+                return response.choices[0].message.content or ""
+            # Anthropic
+            if hasattr(response, "content") and isinstance(response.content, list):
+                return getattr(response.content[0], "text", "") or ""
+            # Gemini
+            if hasattr(response, "candidates"):
+                return response.candidates[0].content.parts[0].text or ""
+            # Ollama
+            if isinstance(response, dict) and "response" in response:
+                return response["response"] or ""
+            # Bedrock (Claude via Bedrock)
+            if isinstance(response, dict) and "content" in response:
+                content = response["content"]
+                if isinstance(content, list) and content:
+                    return content[0].get("text", "") or ""
+        except Exception:
+            pass
+        return None
+
+    def _calc_cost(self, model: str, prompt_tokens: int, completion_tokens: int) -> float:
+        """Estimate USD cost. Prices per 1M tokens [input, output]."""
+        if not model:
+            return 0.0
+
+        m = model.lower()
+
+        PRICES = {
+            # OpenAI
+            "gpt-4o":               (2.50,   10.00),
+            "gpt-4o-mini":          (0.15,    0.60),
+            "gpt-4-turbo":          (10.00,  30.00),
+            "gpt-4":                (30.00,  60.00),
+            "gpt-3.5-turbo":        (0.50,   1.50),
+            "o1":                   (15.00,  60.00),
+            "o3-mini":              (1.10,   4.40),
+            # Anthropic
+            "claude-3-5-sonnet":    (3.00,   15.00),
+            "claude-3-5-haiku":     (0.80,   4.00),
+            "claude-3-opus":        (15.00,  75.00),
+            "claude-3-sonnet":      (3.00,   15.00),
+            "claude-3-haiku":       (0.25,   1.25),
+            # Google
+            "gemini-2.0-flash":     (0.10,   0.40),
+            "gemini-1.5-pro":       (3.50,   10.50),
+            "gemini-1.5-flash":     (0.35,   1.05),
+            "gemini-1.0-pro":       (0.50,   1.50),
+            # Groq (very cheap)
+            "llama-3.1-70b":        (0.59,   0.79),
+            "llama-3.1-8b":         (0.05,   0.08),
+            "llama-3.3-70b":        (0.59,   0.79),
+            "mixtral-8x7b":         (0.24,   0.24),
+            "gemma2-9b":            (0.20,   0.20),
+            # Mistral
+            "mistral-large":        (2.00,   6.00),
+            "mistral-small":        (0.20,   0.60),
+            "codestral":            (0.20,   0.60),
+            "mistral-7b":           (0.25,   0.25),
+            # Together AI
+            "llama-3-70b":          (0.90,   0.90),
+            "llama-3-8b":           (0.20,   0.20),
+            "deepseek-r1":          (0.55,   2.19),
+            "qwen2.5-72b":          (1.20,   1.20),
+            # Ollama — free (local)
+            "ollama":               (0.00,   0.00),
+        }
+
+        for key, (input_price, output_price) in PRICES.items():
+            if key in m:
+                cost = (prompt_tokens * input_price + completion_tokens * output_price) / 1_000_000
+                return round(cost, 8)
+
+        # Fallback
+        return round((prompt_tokens * 0.50 + completion_tokens * 1.50) / 1_000_000, 8)

nirixa-0.1.0/nirixa/middleware.py

@@ -0,0 +1,180 @@
+# nirixa/middleware.py
+# Auto-patchers for all major LLM providers.
+# One call tracks everything without changing your existing code.
+
+from .client import NirixaClient
+
+
+def patch_openai(client: NirixaClient, feature: str = "/api/openai"):
+    """Auto-track all OpenAI chat completions."""
+    try:
+        import openai as _openai
+        original = _openai.chat.completions.create
+
+        def tracked(*args, **kwargs):
+            return client.track(
+                feature=feature,
+                model=kwargs.get("model", "gpt-4o"),
+                provider="openai",
+                prompt=str(kwargs.get("messages", "")),
+                fn=lambda: original(*args, **kwargs),
+            )
+        _openai.chat.completions.create = tracked
+        print(f"[nirixa] ✓ OpenAI patched → tracking '{feature}'")
+        return True
+    except ImportError:
+        return False
+
+
+def patch_anthropic(client: NirixaClient, feature: str = "/api/anthropic"):
+    """Auto-track all Anthropic messages."""
+    try:
+        import anthropic as _anthropic
+        original = _anthropic.resources.messages.Messages.create
+
+        def tracked(self_ref, *args, **kwargs):
+            return client.track(
+                feature=feature,
+                model=kwargs.get("model", "claude-3-5-sonnet-20241022"),
+                provider="anthropic",
+                prompt=str(kwargs.get("messages", "")),
+                fn=lambda: original(self_ref, *args, **kwargs),
+            )
+        _anthropic.resources.messages.Messages.create = tracked
+        print(f"[nirixa] ✓ Anthropic patched → tracking '{feature}'")
+        return True
+    except ImportError:
+        return False
+
+
+def patch_groq(client: NirixaClient, feature: str = "/api/groq"):
+    """Auto-track all Groq completions (Llama, Mixtral, Gemma)."""
+    try:
+        import groq as _groq
+        original = _groq.resources.chat.completions.Completions.create
+
+        def tracked(self_ref, *args, **kwargs):
+            return client.track(
+                feature=feature,
+                model=kwargs.get("model", "llama-3.1-70b-versatile"),
+                provider="groq",
+                prompt=str(kwargs.get("messages", "")),
+                fn=lambda: original(self_ref, *args, **kwargs),
+            )
+        _groq.resources.chat.completions.Completions.create = tracked
+        print(f"[nirixa] ✓ Groq patched → tracking '{feature}'")
+        return True
+    except ImportError:
+        return False
+
+
+def patch_gemini(client: NirixaClient, feature: str = "/api/gemini"):
+    """Auto-track all Google Gemini generate_content calls."""
+    try:
+        import google.generativeai as genai
+        original = genai.GenerativeModel.generate_content
+
+        def tracked(self_ref, *args, **kwargs):
+            return client.track(
+                feature=feature,
+                model=getattr(self_ref, "model_name", "gemini-1.5-pro"),
+                provider="google",
+                prompt=str(args[0] if args else kwargs.get("contents", "")),
+                fn=lambda: original(self_ref, *args, **kwargs),
+            )
+        genai.GenerativeModel.generate_content = tracked
+        print(f"[nirixa] ✓ Gemini patched → tracking '{feature}'")
+        return True
+    except ImportError:
+        return False
+
+
+def patch_mistral(client: NirixaClient, feature: str = "/api/mistral"):
+    """Auto-track all Mistral AI completions."""
+    try:
+        from mistralai import Mistral as _Mistral
+        original = _Mistral.chat.complete
+
+        def tracked(self_ref, *args, **kwargs):
+            return client.track(
+                feature=feature,
+                model=kwargs.get("model", "mistral-large-latest"),
+                provider="mistral",
+                prompt=str(kwargs.get("messages", "")),
+                fn=lambda: original(self_ref, *args, **kwargs),
+            )
+        _Mistral.chat.complete = tracked
+        print(f"[nirixa] ✓ Mistral patched → tracking '{feature}'")
+        return True
+    except ImportError:
+        return False
+
+
+def patch_together(client: NirixaClient, feature: str = "/api/together"):
+    """Auto-track all Together AI completions."""
+    try:
+        import together as _together
+        original = _together.Complete.create
+
+        def tracked(*args, **kwargs):
+            return client.track(
+                feature=feature,
+                model=kwargs.get("model", "meta-llama/Llama-3-70b-chat-hf"),
+                provider="together",
+                prompt=str(kwargs.get("prompt", "")),
+                fn=lambda: original(*args, **kwargs),
+            )
+        _together.Complete.create = tracked
+        print(f"[nirixa] ✓ Together AI patched → tracking '{feature}'")
+        return True
+    except ImportError:
+        return False
+
+
+def patch_ollama(client: NirixaClient, feature: str = "/api/ollama"):
+    """Auto-track all Ollama chat calls (local models)."""
+    try:
+        import ollama as _ollama
+        original = _ollama.chat
+
+        def tracked(*args, **kwargs):
+            return client.track(
+                feature=feature,
+                model=kwargs.get("model", args[0] if args else "llama3"),
+                provider="ollama",
+                prompt=str(kwargs.get("messages", "")),
+                fn=lambda: original(*args, **kwargs),
+            )
+        _ollama.chat = tracked
+        print(f"[nirixa] ✓ Ollama patched → tracking '{feature}'")
+        return True
+    except ImportError:
+        return False
+
+
+def patch_all(client: NirixaClient, feature: str = "/api/llm"):
+    """
+    Patch all installed LLM providers at once.
+
+    Usage:
+        from nirixa import NirixaClient
+        from nirixa.middleware import patch_all
+
+        nirixa = NirixaClient(api_key="nirixa-xxx")
+        patch_all(nirixa)   # patches everything installed
+    """
+    patched = []
+    for name, fn in [
+        ("OpenAI",     lambda: patch_openai(client, feature)),
+        ("Anthropic",  lambda: patch_anthropic(client, feature)),
+        ("Groq",       lambda: patch_groq(client, feature)),
+        ("Gemini",     lambda: patch_gemini(client, feature)),
+        ("Mistral",    lambda: patch_mistral(client, feature)),
+        ("Together",   lambda: patch_together(client, feature)),
+        ("Ollama",     lambda: patch_ollama(client, feature)),
+    ]:
+        if fn():
+            patched.append(name)
+
+    print(f"[nirixa] Patched {len(patched)} providers: {', '.join(patched)}")
+    return patched

nirixa-0.1.0/nirixa/scorer.py

@@ -0,0 +1,119 @@
+# nirixa/scorer.py
+# Lightweight hallucination risk scoring — no external deps needed.
+# Uses heuristic patterns to score LLM output confidence.
+
+import re
+from typing import Optional
+
+
+# Phrases that suggest the model is uncertain / hallucinating
+UNCERTAINTY_PHRASES = [
+    "i'm not sure", "i am not sure", "i think", "i believe", "i'm not certain",
+    "it's possible", "it is possible", "might be", "could be", "may be",
+    "not entirely sure", "to my knowledge", "as far as i know",
+    "i don't have information", "i cannot confirm", "i cannot verify",
+    "i'm unable to verify", "approximately", "roughly", "around",
+    "it seems", "it appears", "seemingly", "supposedly", "allegedly",
+    "some sources say", "according to some", "i recall", "if i remember",
+]
+
+# Phrases that suggest confident, grounded responses
+CONFIDENCE_PHRASES = [
+    "according to", "based on the provided", "the document states",
+    "as stated", "as mentioned", "the data shows", "research shows",
+    "studies show", "it is known that", "it is established",
+]
+
+# Structural risk patterns
+HIGH_RISK_PATTERNS = [
+    r'\b\d{4}\b',           # years — often hallucinated
+    r'\b\d+\.\d+\b',        # version numbers
+    r'\b[A-Z][a-z]+ [A-Z][a-z]+\b',  # proper names
+    r'https?://\S+',        # URLs — often fabricated
+    r'\$[\d,]+',            # dollar amounts
+    r'\b\d+%\b',            # percentages
+]
+
+
+def score(
+    output: str,
+    prompt: Optional[str] = None,
+    model:  Optional[str] = None,
+) -> dict:
+    """
+    Score an LLM output for hallucination risk.
+
+    Returns:
+        {
+            "score": float (0.0 = safe, 1.0 = high risk),
+            "risk":  "LOW" | "MEDIUM" | "HIGH",
+            "flags": list of detected risk signals
+        }
+    """
+    if not output or not output.strip():
+        return {"score": 0.0, "risk": "LOW", "flags": []}
+
+    text   = output.lower()
+    flags  = []
+    score  = 0.0
+
+    # Uncertainty language
+    uncertainty_hits = [p for p in UNCERTAINTY_PHRASES if p in text]
+    if uncertainty_hits:
+        score += 0.15 * min(len(uncertainty_hits), 3)
+        flags.append(f"uncertainty language ({len(uncertainty_hits)} phrases)")
+
+    # Confidence language (negative signal — reduces risk)
+    confidence_hits = [p for p in CONFIDENCE_PHRASES if p in text]
+    if confidence_hits:
+        score -= 0.1 * min(len(confidence_hits), 2)
+
+    # High risk structural patterns
+    pattern_hits = []
+    for pattern in HIGH_RISK_PATTERNS:
+        matches = re.findall(pattern, output)
+        if matches:
+            pattern_hits.extend(matches[:2])
+    if pattern_hits:
+        score += 0.05 * min(len(pattern_hits), 4)
+        flags.append(f"specific claims detected ({len(pattern_hits)} instances)")
+
+    # Very long output = more surface area for errors
+    word_count = len(output.split())
+    if word_count > 500:
+        score += 0.1
+        flags.append("long output (>500 words)")
+    elif word_count > 200:
+        score += 0.05
+
+    # Model-specific adjustments
+    if model:
+        m = model.lower()
+        if "gpt-4" in m or "claude-3-5" in m or "gemini-1.5-pro" in m:
+            score -= 0.05  # frontier models = lower base risk
+        elif "gpt-3.5" in m or "mini" in m or "haiku" in m:
+            score += 0.05  # smaller models = slightly higher risk
+
+    # Prompt-output length ratio
+    if prompt and output:
+        ratio = len(output) / max(len(prompt), 1)
+        if ratio > 5:
+            score += 0.05
+            flags.append("output much longer than prompt")
+
+    # Clamp 0–1
+    score = max(0.0, min(1.0, score))
+
+    # Risk tier
+    if score >= 0.6:
+        risk = "HIGH"
+    elif score >= 0.3:
+        risk = "MEDIUM"
+    else:
+        risk = "LOW"
+
+    return {
+        "score": round(score, 4),
+        "risk":  risk,
+        "flags": flags,
+    }

nirixa-0.1.0/nirixa.egg-info/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: nirixa
+Version: 0.1.0
+Summary: AI Observability & Cost Intelligence — track token costs, latency, and hallucination risk
+Home-page: https://nirixa.in
+Author: Nirixa
+Author-email: nirixaai@gmail.com
+Keywords: llm observability openai anthropic groq gemini mistral ollama cost monitoring hallucination
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.20.0; extra == "anthropic"
+Provides-Extra: groq
+Requires-Dist: groq>=0.4.0; extra == "groq"
+Provides-Extra: gemini
+Requires-Dist: google-generativeai>=0.5.0; extra == "gemini"
+Provides-Extra: mistral
+Requires-Dist: mistralai>=1.0.0; extra == "mistral"
+Provides-Extra: together
+Requires-Dist: together>=1.0.0; extra == "together"
+Provides-Extra: ollama
+Requires-Dist: ollama>=0.1.0; extra == "ollama"
+Provides-Extra: all
+Requires-Dist: openai>=1.0.0; extra == "all"
+Requires-Dist: anthropic>=0.20.0; extra == "all"
+Requires-Dist: groq>=0.4.0; extra == "all"
+Requires-Dist: google-generativeai>=0.5.0; extra == "all"
+Requires-Dist: mistralai>=1.0.0; extra == "all"
+Requires-Dist: together>=1.0.0; extra == "all"
+Requires-Dist: ollama>=0.1.0; extra == "all"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# nirixa
+
+**AI Observability & Cost Intelligence** — track token costs, latency, and hallucination risk for every LLM call.
+
+```bash
+pip install nirixa
+```
+
+## Quick Start
+
+```python
+from nirixa import NirixaClient
+import openai
+
+client = NirixaClient(api_key="nirixa-your-key")
+
+# Wrap any LLM call — zero changes to your existing code
+response = client.track(
+    feature="/api/chat",
+    fn=lambda: openai.chat.completions.create(
+        model="gpt-4o",
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+)
+
+# response is the original OpenAI response — unchanged
+print(response.choices[0].message.content)
+```
+
+## Module-level API
+
+```python
+import nirixa
+import openai
+
+nirixa.init(api_key="nirixa-your-key")
+
+response = nirixa.track(
+    feature="/api/summarize",
+    fn=lambda: openai.chat.completions.create(...)
+)
+```
+
+## Auto-patch (track everything automatically)
+
+```python
+from nirixa import NirixaClient
+from nirixa.middleware import patch_openai
+
+client = NirixaClient(api_key="nirixa-your-key")
+patch_openai(client, feature="/api/chat")
+
+# All openai calls now tracked automatically — no changes needed
+import openai
+openai.chat.completions.create(...)
+```
+
+## Anthropic Support
+
+```python
+from nirixa import NirixaClient
+import anthropic
+
+client  = NirixaClient(api_key="nirixa-your-key")
+claude  = anthropic.Anthropic()
+
+response = client.track(
+    feature="/api/analyze",
+    model="claude-3-5-sonnet-20241022",
+    fn=lambda: claude.messages.create(
+        model="claude-3-5-sonnet-20241022",
+        max_tokens=1024,
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+)
+```
+
+## What gets tracked
+
+| Metric | Description |
+|--------|-------------|
+| Token cost | Per-call USD cost by feature and model |
+| Latency | p50/p95/p99 response times |
+| Hallucination risk | LOW / MEDIUM / HIGH scoring |
+| Prompt drift | Output variance over time |
+| Error rate | Failed calls by endpoint |
+
+## Dashboard
+
+View all your data at [nirixa.in](https://nirixa.in)
+
+---
+निरीक्षा — Observe everything.

nirixa-0.1.0/nirixa.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+setup.py
+nirixa/__init__.py
+nirixa/client.py
+nirixa/middleware.py
+nirixa/scorer.py
+nirixa.egg-info/PKG-INFO
+nirixa.egg-info/SOURCES.txt
+nirixa.egg-info/dependency_links.txt
+nirixa.egg-info/requires.txt
+nirixa.egg-info/top_level.txt

nirixa-0.1.0/nirixa.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nirixa-0.1.0/nirixa.egg-info/requires.txt

@@ -0,0 +1,31 @@
+requests>=2.28.0
+
+[all]
+openai>=1.0.0
+anthropic>=0.20.0
+groq>=0.4.0
+google-generativeai>=0.5.0
+mistralai>=1.0.0
+together>=1.0.0
+ollama>=0.1.0
+
+[anthropic]
+anthropic>=0.20.0
+
+[gemini]
+google-generativeai>=0.5.0
+
+[groq]
+groq>=0.4.0
+
+[mistral]
+mistralai>=1.0.0
+
+[ollama]
+ollama>=0.1.0
+
+[openai]
+openai>=1.0.0
+
+[together]
+together>=1.0.0

nirixa-0.1.0/nirixa.egg-info/top_level.txt

@@ -0,0 +1 @@
+nirixa

nirixa-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

nirixa-0.1.0/setup.py

@@ -0,0 +1,42 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="nirixa",
+    version="0.1.0",
+    description="AI Observability & Cost Intelligence — track token costs, latency, and hallucination risk",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    author="Nirixa",
+    author_email="nirixaai@gmail.com",
+    url="https://nirixa.in",
+    packages=find_packages(),
+    python_requires=">=3.8",
+    install_requires=[
+        "requests>=2.28.0",
+    ],
+    extras_require={
+        "openai":    ["openai>=1.0.0"],
+        "anthropic": ["anthropic>=0.20.0"],
+        "groq":      ["groq>=0.4.0"],
+        "gemini":    ["google-generativeai>=0.5.0"],
+        "mistral":   ["mistralai>=1.0.0"],
+        "together":  ["together>=1.0.0"],
+        "ollama":    ["ollama>=0.1.0"],
+        "all":       [
+            "openai>=1.0.0",
+            "anthropic>=0.20.0",
+            "groq>=0.4.0",
+            "google-generativeai>=0.5.0",
+            "mistralai>=1.0.0",
+            "together>=1.0.0",
+            "ollama>=0.1.0",
+        ],
+    },
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+    ],
+    keywords="llm observability openai anthropic groq gemini mistral ollama cost monitoring hallucination",
+)