ai-audit-logger 0.1.0__tar.gz

ai_audit_logger-0.1.0/PKG-INFO

@@ -0,0 +1,217 @@
+Metadata-Version: 2.4
+Name: ai-audit-logger
+Version: 0.1.0
+Summary: Drop-in audit logging for LLM API calls (OpenAI, Anthropic)
+Project-URL: Source, https://github.com/elliottj06/ai-audit-logger
+Project-URL: Bug Tracker, https://github.com/elliottj06/ai-audit-logger/issues
+Keywords: llm openai anthropic audit logging ai compliance observability
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Logging
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.24.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: all
+Requires-Dist: openai>=1.0.0; extra == "all"
+Requires-Dist: anthropic>=0.20.0; extra == "all"
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# AI Audit Logger
+
+![CI](https://github.com/elliottj06/ai-audit-logger/actions/workflows/ci.yml/badge.svg)
+![Python](https://img.shields.io/badge/python-3.9%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+A self-hosted audit logger for LLM API calls. One line of code captures every OpenAI and Anthropic call — prompts, responses, tokens, cost, latency — and stores it in a queryable database.
+
+Built for teams that need visibility into their AI usage for **debugging**, **cost control**, and **compliance** (EU AI Act, SOC 2).
+
+![AI Audit Logger web dashboard showing total calls, cost, latency, token usage, per-model charts and a filterable table of recent calls](docs/images/dashboard.png)
+
+---
+
+## How it works
+
+```
+Your App  →  SDK (wrap your client)  →  Ingest API  →  Postgres
+                                                            ↓
+                                               CLI / Dashboard / Export
+```
+
+The SDK is a thin wrapper around your existing OpenAI or Anthropic client. It intercepts every call, records it asynchronously (never blocks your app), and ships it to the server.
+
+---
+
+## Quickstart
+
+### 1. Start the server
+
+```bash
+git clone https://github.com/elliottj06/ai-audit-logger
+cd ai-audit-logger
+docker compose up -d
+```
+
+### 2. Wrap your client — one line change
+
+**OpenAI:**
+```python
+from openai import OpenAI
+from ai_audit_logger import wrap
+
+client = wrap(OpenAI())
+
+# Every call now logged automatically — no other changes needed
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "Hello"}]
+)
+```
+
+**Anthropic:**
+```python
+from anthropic import Anthropic
+from ai_audit_logger import wrap
+
+client = wrap(Anthropic())
+
+response = client.messages.create(
+    model="claude-sonnet-4-6",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Hello"}]
+)
+```
+
+### 3. Query your logs
+
+```bash
+pip install -r cli/requirements.txt
+
+python cli/main.py tail        # recent calls
+python cli/main.py stats       # cost + usage summary
+```
+
+**`tail` output:**
+```
+Showing 3 of 3 entries
+
+ Timestamp           Provider    Model                        Tokens        Cost          Latency
+ ------------------- ----------- ---------------------------- ------------ ------------- ---------
+ 2026-11-04 14:23:01 openai      gpt-4o                       18→32         $0.00057      843ms
+ 2026-11-04 14:23:02 anthropic   claude-sonnet-4-6            20→41         $0.00068      1204ms
+ 2026-11-04 14:23:03 openai      gpt-4o-mini                  0→0           n/a           120ms    ERROR
+```
+
+**`stats` output:**
+
+![Output of the stats command: total calls, total cost, tokens in and out, average latency, and a per-model breakdown of calls and cost](docs/images/cli-stats.png)
+
+### 4. Open the dashboard
+
+With the server running, open **http://localhost:8000** for the web dashboard: summary cards, calls and cost by model, and a filterable table of recent calls (click any row for full detail).
+
+---
+
+## Try it without API keys
+
+Run the included example to send simulated log entries and see the CLI in action:
+
+```bash
+python examples/basic_usage.py
+python cli/main.py tail
+python cli/main.py stats
+```
+
+---
+
+## Configuration
+
+```python
+from ai_audit_logger import configure
+
+configure(
+    server_url="http://localhost:8000",  # your server
+    app_name="my-chatbot",              # tag logs by app
+    user_id="user-123",                 # tie logs to a user
+    session_id="session-abc",           # group calls into sessions
+    redact_prompts=False,               # True = omit prompt text from logs
+    enabled=True,
+)
+```
+
+| Env var | Default | Description |
+|---|---|---|
+| `AUDIT_SERVER_URL` | `http://localhost:8000` | Ingest server URL |
+| `AUDIT_APP_NAME` | (none) | Tag logs with your app name |
+| `AUDIT_ENABLED` | `true` | Set `false` to disable without code changes |
+| `AUDIT_REDACT_PROMPTS` | `false` | Omit prompt/response text (privacy mode) |
+
+---
+
+## API
+
+| Endpoint | Method | Description |
+|---|---|---|
+| `/api/v1/log` | POST | Ingest a log entry |
+| `/api/v1/logs` | GET | Query logs (filter by provider, model, user, app, session) |
+| `/api/v1/logs/stats` | GET | Aggregated stats — total calls, cost, tokens, latency |
+| `/health` | GET | Health check |
+
+---
+
+## Project structure
+
+```
+ai-audit-logger/
+├── server/                  # FastAPI ingest + query API
+│   ├── main.py
+│   ├── models.py            # SQLAlchemy LogEntry model
+│   ├── db.py                # Postgres connection
+│   ├── routes/
+│   │   ├── ingest.py        # POST /api/v1/log
+│   │   └── query.py         # GET /api/v1/logs + /stats
+│   └── static/index.html    # Web dashboard (served at /)
+├── sdk/python/              # Python SDK
+│   └── ai_audit_logger/
+│       ├── __init__.py      # wrap() + configure()
+│       ├── wrapper.py       # OpenAI + Anthropic wrappers
+│       ├── client.py        # Fire-and-forget HTTP sender
+│       └── config.py        # AuditConfig dataclass
+├── cli/
+│   └── main.py              # tail / stats / get commands
+├── examples/
+│   └── basic_usage.py       # Try it without API keys
+└── docker-compose.yml
+```
+
+---
+
+## Roadmap
+
+- [ ] TypeScript / Node.js SDK
+- [x] Web dashboard with cost charts
+- [ ] LangChain integration
+- [ ] Publish to PyPI (`pip install ai-audit-logger`)
+- [ ] Tamper-evident log hashing for compliance exports
+- [ ] Slack / email alerts on cost spikes
+
+---
+
+## License
+
+MIT

ai_audit_logger-0.1.0/README.md

@@ -0,0 +1,184 @@
+# AI Audit Logger
+
+![CI](https://github.com/elliottj06/ai-audit-logger/actions/workflows/ci.yml/badge.svg)
+![Python](https://img.shields.io/badge/python-3.9%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+A self-hosted audit logger for LLM API calls. One line of code captures every OpenAI and Anthropic call — prompts, responses, tokens, cost, latency — and stores it in a queryable database.
+
+Built for teams that need visibility into their AI usage for **debugging**, **cost control**, and **compliance** (EU AI Act, SOC 2).
+
+![AI Audit Logger web dashboard showing total calls, cost, latency, token usage, per-model charts and a filterable table of recent calls](docs/images/dashboard.png)
+
+---
+
+## How it works
+
+```
+Your App  →  SDK (wrap your client)  →  Ingest API  →  Postgres
+                                                            ↓
+                                               CLI / Dashboard / Export
+```
+
+The SDK is a thin wrapper around your existing OpenAI or Anthropic client. It intercepts every call, records it asynchronously (never blocks your app), and ships it to the server.
+
+---
+
+## Quickstart
+
+### 1. Start the server
+
+```bash
+git clone https://github.com/elliottj06/ai-audit-logger
+cd ai-audit-logger
+docker compose up -d
+```
+
+### 2. Wrap your client — one line change
+
+**OpenAI:**
+```python
+from openai import OpenAI
+from ai_audit_logger import wrap
+
+client = wrap(OpenAI())
+
+# Every call now logged automatically — no other changes needed
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "Hello"}]
+)
+```
+
+**Anthropic:**
+```python
+from anthropic import Anthropic
+from ai_audit_logger import wrap
+
+client = wrap(Anthropic())
+
+response = client.messages.create(
+    model="claude-sonnet-4-6",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Hello"}]
+)
+```
+
+### 3. Query your logs
+
+```bash
+pip install -r cli/requirements.txt
+
+python cli/main.py tail        # recent calls
+python cli/main.py stats       # cost + usage summary
+```
+
+**`tail` output:**
+```
+Showing 3 of 3 entries
+
+ Timestamp           Provider    Model                        Tokens        Cost          Latency
+ ------------------- ----------- ---------------------------- ------------ ------------- ---------
+ 2026-11-04 14:23:01 openai      gpt-4o                       18→32         $0.00057      843ms
+ 2026-11-04 14:23:02 anthropic   claude-sonnet-4-6            20→41         $0.00068      1204ms
+ 2026-11-04 14:23:03 openai      gpt-4o-mini                  0→0           n/a           120ms    ERROR
+```
+
+**`stats` output:**
+
+![Output of the stats command: total calls, total cost, tokens in and out, average latency, and a per-model breakdown of calls and cost](docs/images/cli-stats.png)
+
+### 4. Open the dashboard
+
+With the server running, open **http://localhost:8000** for the web dashboard: summary cards, calls and cost by model, and a filterable table of recent calls (click any row for full detail).
+
+---
+
+## Try it without API keys
+
+Run the included example to send simulated log entries and see the CLI in action:
+
+```bash
+python examples/basic_usage.py
+python cli/main.py tail
+python cli/main.py stats
+```
+
+---
+
+## Configuration
+
+```python
+from ai_audit_logger import configure
+
+configure(
+    server_url="http://localhost:8000",  # your server
+    app_name="my-chatbot",              # tag logs by app
+    user_id="user-123",                 # tie logs to a user
+    session_id="session-abc",           # group calls into sessions
+    redact_prompts=False,               # True = omit prompt text from logs
+    enabled=True,
+)
+```
+
+| Env var | Default | Description |
+|---|---|---|
+| `AUDIT_SERVER_URL` | `http://localhost:8000` | Ingest server URL |
+| `AUDIT_APP_NAME` | (none) | Tag logs with your app name |
+| `AUDIT_ENABLED` | `true` | Set `false` to disable without code changes |
+| `AUDIT_REDACT_PROMPTS` | `false` | Omit prompt/response text (privacy mode) |
+
+---
+
+## API
+
+| Endpoint | Method | Description |
+|---|---|---|
+| `/api/v1/log` | POST | Ingest a log entry |
+| `/api/v1/logs` | GET | Query logs (filter by provider, model, user, app, session) |
+| `/api/v1/logs/stats` | GET | Aggregated stats — total calls, cost, tokens, latency |
+| `/health` | GET | Health check |
+
+---
+
+## Project structure
+
+```
+ai-audit-logger/
+├── server/                  # FastAPI ingest + query API
+│   ├── main.py
+│   ├── models.py            # SQLAlchemy LogEntry model
+│   ├── db.py                # Postgres connection
+│   ├── routes/
+│   │   ├── ingest.py        # POST /api/v1/log
+│   │   └── query.py         # GET /api/v1/logs + /stats
+│   └── static/index.html    # Web dashboard (served at /)
+├── sdk/python/              # Python SDK
+│   └── ai_audit_logger/
+│       ├── __init__.py      # wrap() + configure()
+│       ├── wrapper.py       # OpenAI + Anthropic wrappers
+│       ├── client.py        # Fire-and-forget HTTP sender
+│       └── config.py        # AuditConfig dataclass
+├── cli/
+│   └── main.py              # tail / stats / get commands
+├── examples/
+│   └── basic_usage.py       # Try it without API keys
+└── docker-compose.yml
+```
+
+---
+
+## Roadmap
+
+- [ ] TypeScript / Node.js SDK
+- [x] Web dashboard with cost charts
+- [ ] LangChain integration
+- [ ] Publish to PyPI (`pip install ai-audit-logger`)
+- [ ] Tamper-evident log hashing for compliance exports
+- [ ] Slack / email alerts on cost spikes
+
+---
+
+## License
+
+MIT

ai_audit_logger-0.1.0/ai_audit_logger/__init__.py

@@ -0,0 +1,53 @@
+from .config import AuditConfig
+from .client import AuditClient
+from .wrapper import WrappedOpenAI, WrappedAnthropic
+
+_default_config = AuditConfig()
+_default_client = AuditClient(_default_config)
+
+
+def configure(
+    server_url: str = None,
+    app_name: str = None,
+    user_id: str = None,
+    session_id: str = None,
+    redact_prompts: bool = False,
+    enabled: bool = True,
+):
+    """Configure global defaults for the audit logger."""
+    global _default_config, _default_client
+    _default_config = AuditConfig(
+        server_url=server_url or _default_config.server_url,
+        app_name=app_name,
+        user_id=user_id,
+        session_id=session_id,
+        redact_prompts=redact_prompts,
+        enabled=enabled,
+    )
+    _default_client = AuditClient(_default_config)
+
+
+def wrap(client, config: AuditConfig = None):
+    """
+    Wrap an OpenAI or Anthropic client to automatically log all LLM calls.
+
+    Usage:
+        from openai import OpenAI
+        from ai_audit_logger import wrap
+
+        client = wrap(OpenAI())
+        # All calls now logged automatically
+    """
+    cfg = config or _default_config
+    audit = AuditClient(cfg)
+    class_name = type(client).__name__
+
+    if "OpenAI" in class_name:
+        return WrappedOpenAI(client, audit, cfg)
+    elif "Anthropic" in class_name:
+        return WrappedAnthropic(client, audit, cfg)
+    else:
+        raise ValueError(f"Unsupported client type: {class_name}. Expected OpenAI or Anthropic.")
+
+
+__all__ = ["wrap", "configure", "AuditConfig", "AuditClient"]

ai_audit_logger-0.1.0/ai_audit_logger/client.py

@@ -0,0 +1,29 @@
+import httpx
+import threading
+from .config import AuditConfig
+
+
+class AuditClient:
+    def __init__(self, config: AuditConfig):
+        self.config = config
+        self._http = httpx.Client(timeout=config.timeout)
+
+    def log(self, **kwargs):
+        if not self.config.enabled:
+            return
+        # Fire-and-forget — never blocks the calling application
+        t = threading.Thread(target=self._send, kwargs=kwargs, daemon=True)
+        t.start()
+
+    def _send(self, **kwargs):
+        try:
+            self._http.post(
+                f"{self.config.server_url}/api/v1/log",
+                json=kwargs,
+                timeout=self.config.timeout,
+            )
+        except Exception:
+            pass  # Silently drop — logging must never crash the app
+
+    def close(self):
+        self._http.close()

ai_audit_logger-0.1.0/ai_audit_logger/config.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass, field
+from typing import Optional
+import os
+
+
+@dataclass
+class AuditConfig:
+    server_url: str = field(default_factory=lambda: os.getenv("AUDIT_SERVER_URL", "http://localhost:8000"))
+    app_name: Optional[str] = field(default_factory=lambda: os.getenv("AUDIT_APP_NAME"))
+    user_id: Optional[str] = None
+    session_id: Optional[str] = None
+    enabled: bool = field(default_factory=lambda: os.getenv("AUDIT_ENABLED", "true").lower() == "true")
+    redact_prompts: bool = field(default_factory=lambda: os.getenv("AUDIT_REDACT_PROMPTS", "false").lower() == "true")
+    timeout: float = 2.0

ai_audit_logger-0.1.0/ai_audit_logger/wrapper.py

@@ -0,0 +1,153 @@
+import time
+import json
+from typing import Optional
+from .config import AuditConfig
+from .client import AuditClient
+
+# Cost per 1M tokens (input, output) in USD
+COST_TABLE = {
+    "gpt-4o-mini": (0.15, 0.60),
+    "gpt-4o": (5.00, 15.00),
+    "gpt-4-turbo": (10.00, 30.00),
+    "gpt-3.5-turbo": (0.50, 1.50),
+    "claude-haiku-4-5": (0.80, 4.00),
+    "claude-sonnet-4-6": (3.00, 15.00),
+    "claude-opus-4-6": (15.00, 75.00),
+    "claude-3-5-sonnet": (3.00, 15.00),
+    "claude-3-5-haiku": (0.80, 4.00),
+}
+
+
+def _calc_cost(model: str, tokens_in: int, tokens_out: int) -> Optional[float]:
+    model_lower = model.lower()
+    for key, (cost_in, cost_out) in COST_TABLE.items():
+        if key in model_lower:
+            return (tokens_in * cost_in + tokens_out * cost_out) / 1_000_000
+    return None
+
+
+# ── OpenAI wrappers ───────────────────────────────────────────────────────────
+
+class WrappedOpenAI:
+    def __init__(self, client, audit: AuditClient, config: AuditConfig):
+        self._client = client
+        self.chat = WrappedChat(client.chat, audit, config)
+
+    def __getattr__(self, name):
+        return getattr(self._client, name)
+
+
+class WrappedChat:
+    def __init__(self, chat, audit: AuditClient, config: AuditConfig):
+        self._chat = chat
+        self.completions = WrappedCompletions(chat.completions, audit, config)
+
+    def __getattr__(self, name):
+        return getattr(self._chat, name)
+
+
+class WrappedCompletions:
+    def __init__(self, completions, audit: AuditClient, config: AuditConfig):
+        self._completions = completions
+        self._audit = audit
+        self._config = config
+
+    def create(self, **kwargs):
+        start = time.time()
+        error = None
+        response = None
+        try:
+            response = self._completions.create(**kwargs)
+            return response
+        except Exception as e:
+            error = str(e)
+            raise
+        finally:
+            latency_ms = (time.time() - start) * 1000
+            model = kwargs.get("model", "unknown")
+            tokens_in = tokens_out = None
+            response_text = None
+
+            if response:
+                if hasattr(response, "usage") and response.usage:
+                    tokens_in = response.usage.prompt_tokens
+                    tokens_out = response.usage.completion_tokens
+                if hasattr(response, "choices") and response.choices:
+                    response_text = response.choices[0].message.content
+
+            self._audit.log(
+                provider="openai",
+                model=model,
+                prompt=None if self._config.redact_prompts else json.dumps(kwargs.get("messages", [])),
+                response=response_text,
+                tokens_in=tokens_in,
+                tokens_out=tokens_out,
+                latency_ms=latency_ms,
+                cost_usd=_calc_cost(model, tokens_in or 0, tokens_out or 0) if tokens_in else None,
+                session_id=self._config.session_id,
+                user_id=self._config.user_id,
+                app_name=self._config.app_name,
+                error=error,
+            )
+
+    def __getattr__(self, name):
+        return getattr(self._completions, name)
+
+
+# ── Anthropic wrappers ────────────────────────────────────────────────────────
+
+class WrappedAnthropic:
+    def __init__(self, client, audit: AuditClient, config: AuditConfig):
+        self._client = client
+        self.messages = WrappedAnthropicMessages(client.messages, audit, config)
+
+    def __getattr__(self, name):
+        return getattr(self._client, name)
+
+
+class WrappedAnthropicMessages:
+    def __init__(self, messages, audit: AuditClient, config: AuditConfig):
+        self._messages = messages
+        self._audit = audit
+        self._config = config
+
+    def create(self, **kwargs):
+        start = time.time()
+        error = None
+        response = None
+        try:
+            response = self._messages.create(**kwargs)
+            return response
+        except Exception as e:
+            error = str(e)
+            raise
+        finally:
+            latency_ms = (time.time() - start) * 1000
+            model = kwargs.get("model", "unknown")
+            tokens_in = tokens_out = None
+            response_text = None
+
+            if response:
+                if hasattr(response, "usage"):
+                    tokens_in = response.usage.input_tokens
+                    tokens_out = response.usage.output_tokens
+                if hasattr(response, "content") and response.content:
+                    response_text = response.content[0].text
+
+            self._audit.log(
+                provider="anthropic",
+                model=model,
+                prompt=None if self._config.redact_prompts else json.dumps(kwargs.get("messages", [])),
+                response=response_text,
+                tokens_in=tokens_in,
+                tokens_out=tokens_out,
+                latency_ms=latency_ms,
+                cost_usd=_calc_cost(model, tokens_in or 0, tokens_out or 0) if tokens_in else None,
+                session_id=self._config.session_id,
+                user_id=self._config.user_id,
+                app_name=self._config.app_name,
+                error=error,
+            )
+
+    def __getattr__(self, name):
+        return getattr(self._messages, name)

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

@@ -0,0 +1,217 @@
+Metadata-Version: 2.4
+Name: ai-audit-logger
+Version: 0.1.0
+Summary: Drop-in audit logging for LLM API calls (OpenAI, Anthropic)
+Project-URL: Source, https://github.com/elliottj06/ai-audit-logger
+Project-URL: Bug Tracker, https://github.com/elliottj06/ai-audit-logger/issues
+Keywords: llm openai anthropic audit logging ai compliance observability
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Logging
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.24.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: all
+Requires-Dist: openai>=1.0.0; extra == "all"
+Requires-Dist: anthropic>=0.20.0; extra == "all"
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# AI Audit Logger
+
+![CI](https://github.com/elliottj06/ai-audit-logger/actions/workflows/ci.yml/badge.svg)
+![Python](https://img.shields.io/badge/python-3.9%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+A self-hosted audit logger for LLM API calls. One line of code captures every OpenAI and Anthropic call — prompts, responses, tokens, cost, latency — and stores it in a queryable database.
+
+Built for teams that need visibility into their AI usage for **debugging**, **cost control**, and **compliance** (EU AI Act, SOC 2).
+
+![AI Audit Logger web dashboard showing total calls, cost, latency, token usage, per-model charts and a filterable table of recent calls](docs/images/dashboard.png)
+
+---
+
+## How it works
+
+```
+Your App  →  SDK (wrap your client)  →  Ingest API  →  Postgres
+                                                            ↓
+                                               CLI / Dashboard / Export
+```
+
+The SDK is a thin wrapper around your existing OpenAI or Anthropic client. It intercepts every call, records it asynchronously (never blocks your app), and ships it to the server.
+
+---
+
+## Quickstart
+
+### 1. Start the server
+
+```bash
+git clone https://github.com/elliottj06/ai-audit-logger
+cd ai-audit-logger
+docker compose up -d
+```
+
+### 2. Wrap your client — one line change
+
+**OpenAI:**
+```python
+from openai import OpenAI
+from ai_audit_logger import wrap
+
+client = wrap(OpenAI())
+
+# Every call now logged automatically — no other changes needed
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "Hello"}]
+)
+```
+
+**Anthropic:**
+```python
+from anthropic import Anthropic
+from ai_audit_logger import wrap
+
+client = wrap(Anthropic())
+
+response = client.messages.create(
+    model="claude-sonnet-4-6",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Hello"}]
+)
+```
+
+### 3. Query your logs
+
+```bash
+pip install -r cli/requirements.txt
+
+python cli/main.py tail        # recent calls
+python cli/main.py stats       # cost + usage summary
+```
+
+**`tail` output:**
+```
+Showing 3 of 3 entries
+
+ Timestamp           Provider    Model                        Tokens        Cost          Latency
+ ------------------- ----------- ---------------------------- ------------ ------------- ---------
+ 2026-11-04 14:23:01 openai      gpt-4o                       18→32         $0.00057      843ms
+ 2026-11-04 14:23:02 anthropic   claude-sonnet-4-6            20→41         $0.00068      1204ms
+ 2026-11-04 14:23:03 openai      gpt-4o-mini                  0→0           n/a           120ms    ERROR
+```
+
+**`stats` output:**
+
+![Output of the stats command: total calls, total cost, tokens in and out, average latency, and a per-model breakdown of calls and cost](docs/images/cli-stats.png)
+
+### 4. Open the dashboard
+
+With the server running, open **http://localhost:8000** for the web dashboard: summary cards, calls and cost by model, and a filterable table of recent calls (click any row for full detail).
+
+---
+
+## Try it without API keys
+
+Run the included example to send simulated log entries and see the CLI in action:
+
+```bash
+python examples/basic_usage.py
+python cli/main.py tail
+python cli/main.py stats
+```
+
+---
+
+## Configuration
+
+```python
+from ai_audit_logger import configure
+
+configure(
+    server_url="http://localhost:8000",  # your server
+    app_name="my-chatbot",              # tag logs by app
+    user_id="user-123",                 # tie logs to a user
+    session_id="session-abc",           # group calls into sessions
+    redact_prompts=False,               # True = omit prompt text from logs
+    enabled=True,
+)
+```
+
+| Env var | Default | Description |
+|---|---|---|
+| `AUDIT_SERVER_URL` | `http://localhost:8000` | Ingest server URL |
+| `AUDIT_APP_NAME` | (none) | Tag logs with your app name |
+| `AUDIT_ENABLED` | `true` | Set `false` to disable without code changes |
+| `AUDIT_REDACT_PROMPTS` | `false` | Omit prompt/response text (privacy mode) |
+
+---
+
+## API
+
+| Endpoint | Method | Description |
+|---|---|---|
+| `/api/v1/log` | POST | Ingest a log entry |
+| `/api/v1/logs` | GET | Query logs (filter by provider, model, user, app, session) |
+| `/api/v1/logs/stats` | GET | Aggregated stats — total calls, cost, tokens, latency |
+| `/health` | GET | Health check |
+
+---
+
+## Project structure
+
+```
+ai-audit-logger/
+├── server/                  # FastAPI ingest + query API
+│   ├── main.py
+│   ├── models.py            # SQLAlchemy LogEntry model
+│   ├── db.py                # Postgres connection
+│   ├── routes/
+│   │   ├── ingest.py        # POST /api/v1/log
+│   │   └── query.py         # GET /api/v1/logs + /stats
+│   └── static/index.html    # Web dashboard (served at /)
+├── sdk/python/              # Python SDK
+│   └── ai_audit_logger/
+│       ├── __init__.py      # wrap() + configure()
+│       ├── wrapper.py       # OpenAI + Anthropic wrappers
+│       ├── client.py        # Fire-and-forget HTTP sender
+│       └── config.py        # AuditConfig dataclass
+├── cli/
+│   └── main.py              # tail / stats / get commands
+├── examples/
+│   └── basic_usage.py       # Try it without API keys
+└── docker-compose.yml
+```
+
+---
+
+## Roadmap
+
+- [ ] TypeScript / Node.js SDK
+- [x] Web dashboard with cost charts
+- [ ] LangChain integration
+- [ ] Publish to PyPI (`pip install ai-audit-logger`)
+- [ ] Tamper-evident log hashing for compliance exports
+- [ ] Slack / email alerts on cost spikes
+
+---
+
+## License
+
+MIT

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

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+setup.py
+ai_audit_logger/__init__.py
+ai_audit_logger/client.py
+ai_audit_logger/config.py
+ai_audit_logger/wrapper.py
+ai_audit_logger.egg-info/PKG-INFO
+ai_audit_logger.egg-info/SOURCES.txt
+ai_audit_logger.egg-info/dependency_links.txt
+ai_audit_logger.egg-info/requires.txt
+ai_audit_logger.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,11 @@
+httpx>=0.24.0
+
+[all]
+openai>=1.0.0
+anthropic>=0.20.0
+
+[anthropic]
+anthropic>=0.20.0
+
+[openai]
+openai>=1.0.0

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

@@ -0,0 +1 @@
+ai_audit_logger

ai_audit_logger-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"

ai_audit_logger-0.1.0/setup.cfg

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

ai_audit_logger-0.1.0/setup.py

@@ -0,0 +1,38 @@
+from setuptools import setup, find_packages
+import os
+
+try:
+    readme = open(os.path.join(os.path.dirname(__file__), "../../README.md"), encoding="utf-8").read()
+except FileNotFoundError:
+    readme = "Drop-in audit logging for LLM API calls (OpenAI, Anthropic)"
+
+setup(
+    name="ai-audit-logger",
+    version="0.1.0",
+    description="Drop-in audit logging for LLM API calls (OpenAI, Anthropic)",
+    long_description=readme,
+    long_description_content_type="text/markdown",
+    packages=find_packages(),
+    python_requires=">=3.9",
+    install_requires=[
+        "httpx>=0.24.0",
+    ],
+    extras_require={
+        "openai": ["openai>=1.0.0"],
+        "anthropic": ["anthropic>=0.20.0"],
+        "all": ["openai>=1.0.0", "anthropic>=0.20.0"],
+    },
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "Topic :: System :: Logging",
+        "Intended Audience :: Developers",
+    ],
+    keywords="llm openai anthropic audit logging ai compliance observability",
+    project_urls={
+        "Source": "https://github.com/elliottj06/ai-audit-logger",
+        "Bug Tracker": "https://github.com/elliottj06/ai-audit-logger/issues",
+    },
+)