agentbill-py-langchain 4.0.1__tar.gz

agentbill_py_langchain-4.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AgentBill
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agentbill_py_langchain-4.0.1/PKG-INFO

@@ -0,0 +1,208 @@
+Metadata-Version: 2.4
+Name: agentbill-py-langchain
+Version: 4.0.1
+Summary: LangChain callback handler for automatic usage tracking and billing with AgentBill
+Home-page: https://github.com/Agent-Bill/langchain
+Author: AgentBill
+Author-email: dominic@agentbill.io
+Keywords: langchain agentbill ai agent billing usage-tracking openai anthropic llm observability callbacks
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langchain>=0.1.0
+Requires-Dist: requests>=2.28.0
+Provides-Extra: openai
+Requires-Dist: langchain-openai>=0.0.1; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: langchain-anthropic>=0.0.1; extra == "anthropic"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# AgentBill LangChain Integration
+
+Automatic usage tracking and billing for LangChain applications.
+
+[![PyPI version](https://badge.fury.io/py/agentbill-langchain.svg)](https://pypi.org/project/agentbill-langchain/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+Install via pip:
+
+```bash
+pip install agentbill-langchain
+```
+
+With OpenAI support:
+```bash
+pip install agentbill-langchain[openai]
+```
+
+With Anthropic support:
+```bash
+pip install agentbill-langchain[anthropic]
+```
+
+## Quick Start
+
+```python
+from agentbill_langchain import AgentBillCallback
+from langchain_openai import ChatOpenAI
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+
+# 1. Initialize AgentBill callback
+callback = AgentBillCallback(
+    api_key="agb_your_api_key_here",  # Get from AgentBill dashboard
+    base_url="https://bgwyprqxtdreuutzpbgw.supabase.co",
+    customer_id="customer-123",
+    debug=True
+)
+
+# 2. Create LangChain chain with callback
+llm = ChatOpenAI(model="gpt-4o-mini")
+prompt = PromptTemplate.from_template("Tell me a joke about {topic}")
+chain = LLMChain(llm=llm, prompt=prompt)
+
+# 3. Run - everything is auto-tracked!
+result = chain.invoke(
+    {"topic": "programming"},
+    config={"callbacks": [callback]}
+)
+
+print(result["text"])
+
+# ✅ Automatically captured:
+# - Prompt text (hashed for privacy)
+# - Model name (gpt-4o-mini)
+# - Provider (openai)
+# - Token usage (prompt + completion)
+# - Latency (ms)
+# - Costs (calculated automatically)
+```
+
+## Features
+
+- ✅ **Zero-config instrumentation** - Just add the callback
+- ✅ **Automatic token tracking** - Captures all LLM calls
+- ✅ **Multi-provider support** - OpenAI, Anthropic, any LangChain LLM
+- ✅ **Chain tracking** - Tracks entire chain executions
+- ✅ **Cost calculation** - Auto-calculates costs per model
+- ✅ **Prompt profitability** - Compare costs vs revenue
+- ✅ **OpenTelemetry compatible** - Standard observability
+
+## Advanced Usage
+
+### Track Custom Revenue
+
+```python
+# Track revenue for profitability analysis
+callback.track_revenue(
+    event_name="chat_completion",
+    revenue=0.50,  # What you charged the customer
+    metadata={"subscription_tier": "pro"}
+)
+```
+
+### Use with Agents
+
+```python
+from langchain.agents import initialize_agent, load_tools
+
+tools = load_tools(["serpapi", "llm-math"], llm=llm)
+agent = initialize_agent(
+    tools,
+    llm,
+    agent="zero-shot-react-description",
+    callbacks=[callback]  # Add callback here
+)
+
+# All agent steps auto-tracked!
+response = agent.run("What is 25% of 300?")
+```
+
+### Use with Sequential Chains
+
+```python
+from langchain.chains import SimpleSequentialChain
+
+# All chain steps tracked automatically
+overall_chain = SimpleSequentialChain(
+    chains=[chain1, chain2, chain3],
+    callbacks=[callback]
+)
+
+result = overall_chain.run(input_text)
+```
+
+## Configuration
+
+```python
+callback = AgentBillCallback(
+    api_key="agb_...",           # Required - get from dashboard
+    base_url="https://...",      # Required - your AgentBill instance
+    customer_id="customer-123",  # Optional - for multi-tenant apps
+    account_id="account-456",    # Optional - for account-level tracking
+    debug=True,                  # Optional - enable debug logging
+    batch_size=10,               # Optional - batch signals before sending
+    flush_interval=5.0           # Optional - flush interval in seconds
+)
+```
+
+## How It Works
+
+The callback hooks into LangChain's lifecycle:
+
+1. **on_llm_start** - Captures prompt, model, provider
+2. **on_llm_end** - Captures tokens, latency, response
+3. **on_llm_error** - Captures errors and retries
+4. **on_chain_start** - Tracks chain execution start
+5. **on_chain_end** - Tracks chain completion
+
+All data is sent to AgentBill via the `record-signals` API endpoint with proper authentication.
+
+## Supported Models
+
+Auto-cost calculation for:
+- OpenAI: GPT-4, GPT-4o, GPT-3.5-turbo, etc.
+- Anthropic: Claude 3.5 Sonnet, Claude 3 Opus, etc.
+- Any LangChain-compatible LLM
+
+## Troubleshooting
+
+### Not seeing data in dashboard?
+
+1. Check API key is correct
+2. Enable `debug=True` to see logs
+3. Verify `base_url` matches your instance
+4. Check network connectivity to AgentBill
+
+### Token counts are zero?
+
+- Some LLMs don't return token usage
+- Callback will estimate based on response length
+- OpenAI/Anthropic provide accurate counts
+
+## License
+
+MIT

agentbill_py_langchain-4.0.1/README.md

@@ -0,0 +1,168 @@
+# AgentBill LangChain Integration
+
+Automatic usage tracking and billing for LangChain applications.
+
+[![PyPI version](https://badge.fury.io/py/agentbill-langchain.svg)](https://pypi.org/project/agentbill-langchain/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+Install via pip:
+
+```bash
+pip install agentbill-langchain
+```
+
+With OpenAI support:
+```bash
+pip install agentbill-langchain[openai]
+```
+
+With Anthropic support:
+```bash
+pip install agentbill-langchain[anthropic]
+```
+
+## Quick Start
+
+```python
+from agentbill_langchain import AgentBillCallback
+from langchain_openai import ChatOpenAI
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+
+# 1. Initialize AgentBill callback
+callback = AgentBillCallback(
+    api_key="agb_your_api_key_here",  # Get from AgentBill dashboard
+    base_url="https://bgwyprqxtdreuutzpbgw.supabase.co",
+    customer_id="customer-123",
+    debug=True
+)
+
+# 2. Create LangChain chain with callback
+llm = ChatOpenAI(model="gpt-4o-mini")
+prompt = PromptTemplate.from_template("Tell me a joke about {topic}")
+chain = LLMChain(llm=llm, prompt=prompt)
+
+# 3. Run - everything is auto-tracked!
+result = chain.invoke(
+    {"topic": "programming"},
+    config={"callbacks": [callback]}
+)
+
+print(result["text"])
+
+# ✅ Automatically captured:
+# - Prompt text (hashed for privacy)
+# - Model name (gpt-4o-mini)
+# - Provider (openai)
+# - Token usage (prompt + completion)
+# - Latency (ms)
+# - Costs (calculated automatically)
+```
+
+## Features
+
+- ✅ **Zero-config instrumentation** - Just add the callback
+- ✅ **Automatic token tracking** - Captures all LLM calls
+- ✅ **Multi-provider support** - OpenAI, Anthropic, any LangChain LLM
+- ✅ **Chain tracking** - Tracks entire chain executions
+- ✅ **Cost calculation** - Auto-calculates costs per model
+- ✅ **Prompt profitability** - Compare costs vs revenue
+- ✅ **OpenTelemetry compatible** - Standard observability
+
+## Advanced Usage
+
+### Track Custom Revenue
+
+```python
+# Track revenue for profitability analysis
+callback.track_revenue(
+    event_name="chat_completion",
+    revenue=0.50,  # What you charged the customer
+    metadata={"subscription_tier": "pro"}
+)
+```
+
+### Use with Agents
+
+```python
+from langchain.agents import initialize_agent, load_tools
+
+tools = load_tools(["serpapi", "llm-math"], llm=llm)
+agent = initialize_agent(
+    tools,
+    llm,
+    agent="zero-shot-react-description",
+    callbacks=[callback]  # Add callback here
+)
+
+# All agent steps auto-tracked!
+response = agent.run("What is 25% of 300?")
+```
+
+### Use with Sequential Chains
+
+```python
+from langchain.chains import SimpleSequentialChain
+
+# All chain steps tracked automatically
+overall_chain = SimpleSequentialChain(
+    chains=[chain1, chain2, chain3],
+    callbacks=[callback]
+)
+
+result = overall_chain.run(input_text)
+```
+
+## Configuration
+
+```python
+callback = AgentBillCallback(
+    api_key="agb_...",           # Required - get from dashboard
+    base_url="https://...",      # Required - your AgentBill instance
+    customer_id="customer-123",  # Optional - for multi-tenant apps
+    account_id="account-456",    # Optional - for account-level tracking
+    debug=True,                  # Optional - enable debug logging
+    batch_size=10,               # Optional - batch signals before sending
+    flush_interval=5.0           # Optional - flush interval in seconds
+)
+```
+
+## How It Works
+
+The callback hooks into LangChain's lifecycle:
+
+1. **on_llm_start** - Captures prompt, model, provider
+2. **on_llm_end** - Captures tokens, latency, response
+3. **on_llm_error** - Captures errors and retries
+4. **on_chain_start** - Tracks chain execution start
+5. **on_chain_end** - Tracks chain completion
+
+All data is sent to AgentBill via the `record-signals` API endpoint with proper authentication.
+
+## Supported Models
+
+Auto-cost calculation for:
+- OpenAI: GPT-4, GPT-4o, GPT-3.5-turbo, etc.
+- Anthropic: Claude 3.5 Sonnet, Claude 3 Opus, etc.
+- Any LangChain-compatible LLM
+
+## Troubleshooting
+
+### Not seeing data in dashboard?
+
+1. Check API key is correct
+2. Enable `debug=True` to see logs
+3. Verify `base_url` matches your instance
+4. Check network connectivity to AgentBill
+
+### Token counts are zero?
+
+- Some LLMs don't return token usage
+- Callback will estimate based on response length
+- OpenAI/Anthropic provide accurate counts
+
+## License
+
+MIT

agentbill_py_langchain-4.0.1/agentbill_langchain/__init__.py

@@ -0,0 +1,9 @@
+"""AgentBill LangChain Integration
+
+Zero-config callback handler for tracking LangChain usage in AgentBill.
+"""
+
+from .callback import AgentBillCallback
+
+__version__ = "4.0.1"
+__all__ = ["AgentBillCallback"]

agentbill_py_langchain-4.0.1/agentbill_langchain/callback.py

@@ -0,0 +1,332 @@
+"""AgentBill LangChain Callback Handler"""
+
+import time
+import hashlib
+import json
+from typing import Any, Dict, List, Optional
+from uuid import UUID
+
+try:
+    from langchain.callbacks.base import BaseCallbackHandler
+    from langchain.schema import LLMResult
+except ImportError:
+    raise ImportError(
+        "langchain is not installed. Install with: pip install langchain"
+    )
+
+import requests
+
+
+class AgentBillCallback(BaseCallbackHandler):
+    """LangChain callback handler that sends usage data to AgentBill.
+    
+    Example:
+        callback = AgentBillCallback(
+            api_key="agb_your_key",
+            base_url="https://your-instance.supabase.co",
+            customer_id="customer-123"
+        )
+        
+        llm = ChatOpenAI(callbacks=[callback])
+        result = llm.invoke("Hello!")
+    """
+    
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str,
+        customer_id: Optional[str] = None,
+        account_id: Optional[str] = None,
+        debug: bool = False,
+        batch_size: int = 10,
+        flush_interval: float = 5.0
+    ):
+        """Initialize AgentBill callback.
+        
+        Args:
+            api_key: AgentBill API key (get from dashboard)
+            base_url: AgentBill base URL (e.g., https://xxx.supabase.co)
+            customer_id: Optional customer ID for tracking
+            account_id: Optional account ID for tracking
+            debug: Enable debug logging
+            batch_size: Number of signals to batch before sending
+            flush_interval: Seconds between automatic flushes
+        """
+        super().__init__()
+        self.api_key = api_key
+        self.base_url = base_url.rstrip('/')
+        self.customer_id = customer_id
+        self.account_id = account_id
+        self.debug = debug
+        self.batch_size = batch_size
+        self.flush_interval = flush_interval
+        
+        # Track active LLM calls
+        self._active_runs: Dict[str, Dict[str, Any]] = {}
+        
+        # Batch queue
+        self._signal_queue: List[Dict[str, Any]] = []
+        self._last_flush = time.time()
+        
+        if self.debug:
+            print(f"[AgentBill] Initialized with base_url={self.base_url}")
+    
+    def _hash_prompt(self, text: str) -> str:
+        """Hash prompt for privacy."""
+        return hashlib.sha256(text.encode()).hexdigest()
+    
+    def _extract_provider(self, serialized: Dict[str, Any]) -> str:
+        """Extract provider from LLM serialization."""
+        # Check id field
+        for id_item in serialized.get("id", []):
+            if "openai" in id_item.lower():
+                return "openai"
+            if "anthropic" in id_item.lower():
+                return "anthropic"
+            if "cohere" in id_item.lower():
+                return "cohere"
+            if "bedrock" in id_item.lower():
+                return "bedrock"
+        
+        # Check kwargs
+        kwargs = serialized.get("kwargs", {})
+        if "openai" in str(kwargs).lower():
+            return "openai"
+        if "anthropic" in str(kwargs).lower():
+            return "anthropic"
+        
+        return "unknown"
+    
+    def _extract_model(self, serialized: Dict[str, Any]) -> str:
+        """Extract model name from LLM serialization."""
+        # Try model_name in kwargs
+        kwargs = serialized.get("kwargs", {})
+        if "model_name" in kwargs:
+            return kwargs["model_name"]
+        if "model" in kwargs:
+            return kwargs["model"]
+        
+        # Try id field
+        for id_item in serialized.get("id", []):
+            if "gpt" in id_item.lower():
+                return id_item
+            if "claude" in id_item.lower():
+                return id_item
+        
+        return "unknown"
+    
+    def _send_signal(self, signal: Dict[str, Any]) -> None:
+        """Send signal to AgentBill."""
+        try:
+            url = f"{self.base_url}/functions/v1/record-signals"
+            headers = {
+                "Content-Type": "application/json",
+                "X-API-Key": self.api_key
+            }
+            
+            if self.debug:
+                print(f"[AgentBill] Sending signal: {signal.get('event_name')}")
+            
+            response = requests.post(url, json=[signal], headers=headers, timeout=10)
+            
+            if response.status_code != 200:
+                print(f"[AgentBill] Error sending signal: {response.status_code} {response.text}")
+            elif self.debug:
+                print(f"[AgentBill] Signal sent successfully")
+                
+        except Exception as e:
+            if self.debug:
+                print(f"[AgentBill] Error sending signal: {e}")
+    
+    def _queue_signal(self, signal: Dict[str, Any]) -> None:
+        """Add signal to queue and flush if needed."""
+        self._signal_queue.append(signal)
+        
+        # Flush if batch size reached or interval exceeded
+        now = time.time()
+        should_flush = (
+            len(self._signal_queue) >= self.batch_size or
+            (now - self._last_flush) >= self.flush_interval
+        )
+        
+        if should_flush:
+            self.flush()
+    
+    def flush(self) -> None:
+        """Flush queued signals to AgentBill."""
+        if not self._signal_queue:
+            return
+        
+        try:
+            url = f"{self.base_url}/functions/v1/record-signals"
+            headers = {
+                "Content-Type": "application/json",
+                "X-API-Key": self.api_key
+            }
+            
+            if self.debug:
+                print(f"[AgentBill] Flushing {len(self._signal_queue)} signals")
+            
+            response = requests.post(
+                url,
+                json=self._signal_queue,
+                headers=headers,
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                self._signal_queue.clear()
+                self._last_flush = time.time()
+                if self.debug:
+                    print(f"[AgentBill] Flush successful")
+            else:
+                print(f"[AgentBill] Flush error: {response.status_code} {response.text}")
+                
+        except Exception as e:
+            if self.debug:
+                print(f"[AgentBill] Flush error: {e}")
+    
+    def on_llm_start(
+        self,
+        serialized: Dict[str, Any],
+        prompts: List[str],
+        **kwargs: Any
+    ) -> None:
+        """Called when LLM starts."""
+        run_id = kwargs.get("run_id") or str(UUID(int=0))
+        
+        # Extract metadata
+        provider = self._extract_provider(serialized)
+        model = self._extract_model(serialized)
+        
+        # Store run info
+        self._active_runs[str(run_id)] = {
+            "start_time": time.time(),
+            "prompts": prompts,
+            "provider": provider,
+            "model": model,
+            "prompt_hash": self._hash_prompt(prompts[0]) if prompts else None,
+            "prompt_sample": prompts[0][:200] if prompts else None,
+        }
+        
+        if self.debug:
+            print(f"[AgentBill] LLM started: {model} ({provider})")
+    
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """Called when LLM ends."""
+        run_id = str(kwargs.get("run_id", ""))
+        run_info = self._active_runs.pop(run_id, None)
+        
+        if not run_info:
+            return
+        
+        # Calculate latency
+        latency_ms = int((time.time() - run_info["start_time"]) * 1000)
+        
+        # Extract token usage
+        llm_output = response.llm_output or {}
+        token_usage = llm_output.get("token_usage", {})
+        
+        prompt_tokens = token_usage.get("prompt_tokens", 0)
+        completion_tokens = token_usage.get("completion_tokens", 0)
+        total_tokens = token_usage.get("total_tokens", prompt_tokens + completion_tokens)
+        
+        # Build signal
+        signal = {
+            "event_name": "langchain_llm_call",
+            "model": run_info["model"],
+            "provider": run_info["provider"],
+            "prompt_hash": run_info["prompt_hash"],
+            "prompt_sample": run_info["prompt_sample"],
+            "metrics": {
+                "prompt_tokens": prompt_tokens,
+                "completion_tokens": completion_tokens,
+                "total_tokens": total_tokens,
+            },
+            "latency_ms": latency_ms,
+            "data_source": "langchain",
+        }
+        
+        # Add customer/account if provided with UUID detection
+        if self.customer_id:
+            # Check if UUID format - send as customer_id, else customer_external_id
+            import re
+            uuid_regex = re.compile(r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$', re.IGNORECASE)
+            is_uuid = bool(uuid_regex.match(self.customer_id))
+            if is_uuid:
+                signal["customer_id"] = self.customer_id
+            else:
+                signal["customer_external_id"] = self.customer_id
+        if self.account_id:
+            signal["account_id"] = self.account_id
+        
+        # Queue signal
+        self._queue_signal(signal)
+        
+        if self.debug:
+            print(f"[AgentBill] LLM ended: {total_tokens} tokens, {latency_ms}ms")
+    
+    def on_llm_error(self, error: Exception, **kwargs: Any) -> None:
+        """Called when LLM errors."""
+        run_id = str(kwargs.get("run_id", ""))
+        self._active_runs.pop(run_id, None)
+        
+        if self.debug:
+            print(f"[AgentBill] LLM error: {error}")
+    
+    def on_chain_start(
+        self,
+        serialized: Dict[str, Any],
+        inputs: Dict[str, Any],
+        **kwargs: Any
+    ) -> None:
+        """Called when chain starts."""
+        if self.debug:
+            chain_name = serialized.get("id", ["unknown"])[-1]
+            print(f"[AgentBill] Chain started: {chain_name}")
+    
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
+        """Called when chain ends."""
+        if self.debug:
+            print(f"[AgentBill] Chain ended")
+    
+    def track_revenue(
+        self,
+        event_name: str,
+        revenue: float,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> None:
+        """Track revenue for profitability analysis.
+        
+        Args:
+            event_name: Event name (e.g., "chat_completion")
+            revenue: Revenue amount (what you charged)
+            metadata: Additional metadata
+        """
+        signal = {
+            "event_name": event_name,
+            "conversion_value": revenue,
+            "revenue_source": "langchain",
+            "data": metadata or {},
+        }
+        
+        if self.customer_id:
+            # Check if UUID format - send as customer_id, else customer_external_id
+            import re
+            uuid_regex = re.compile(r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$', re.IGNORECASE)
+            is_uuid = bool(uuid_regex.match(self.customer_id))
+            if is_uuid:
+                signal["customer_id"] = self.customer_id
+            else:
+                signal["customer_external_id"] = self.customer_id
+        if self.account_id:
+            signal["account_id"] = self.account_id
+        
+        self._queue_signal(signal)
+        
+        if self.debug:
+            print(f"[AgentBill] Revenue tracked: ${revenue}")
+    
+    def __del__(self):
+        """Flush on cleanup."""
+        self.flush()

agentbill_py_langchain-4.0.1/agentbill_py_langchain.egg-info/PKG-INFO

@@ -0,0 +1,208 @@
+Metadata-Version: 2.4
+Name: agentbill-py-langchain
+Version: 4.0.1
+Summary: LangChain callback handler for automatic usage tracking and billing with AgentBill
+Home-page: https://github.com/Agent-Bill/langchain
+Author: AgentBill
+Author-email: dominic@agentbill.io
+Keywords: langchain agentbill ai agent billing usage-tracking openai anthropic llm observability callbacks
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langchain>=0.1.0
+Requires-Dist: requests>=2.28.0
+Provides-Extra: openai
+Requires-Dist: langchain-openai>=0.0.1; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: langchain-anthropic>=0.0.1; extra == "anthropic"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# AgentBill LangChain Integration
+
+Automatic usage tracking and billing for LangChain applications.
+
+[![PyPI version](https://badge.fury.io/py/agentbill-langchain.svg)](https://pypi.org/project/agentbill-langchain/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+Install via pip:
+
+```bash
+pip install agentbill-langchain
+```
+
+With OpenAI support:
+```bash
+pip install agentbill-langchain[openai]
+```
+
+With Anthropic support:
+```bash
+pip install agentbill-langchain[anthropic]
+```
+
+## Quick Start
+
+```python
+from agentbill_langchain import AgentBillCallback
+from langchain_openai import ChatOpenAI
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+
+# 1. Initialize AgentBill callback
+callback = AgentBillCallback(
+    api_key="agb_your_api_key_here",  # Get from AgentBill dashboard
+    base_url="https://bgwyprqxtdreuutzpbgw.supabase.co",
+    customer_id="customer-123",
+    debug=True
+)
+
+# 2. Create LangChain chain with callback
+llm = ChatOpenAI(model="gpt-4o-mini")
+prompt = PromptTemplate.from_template("Tell me a joke about {topic}")
+chain = LLMChain(llm=llm, prompt=prompt)
+
+# 3. Run - everything is auto-tracked!
+result = chain.invoke(
+    {"topic": "programming"},
+    config={"callbacks": [callback]}
+)
+
+print(result["text"])
+
+# ✅ Automatically captured:
+# - Prompt text (hashed for privacy)
+# - Model name (gpt-4o-mini)
+# - Provider (openai)
+# - Token usage (prompt + completion)
+# - Latency (ms)
+# - Costs (calculated automatically)
+```
+
+## Features
+
+- ✅ **Zero-config instrumentation** - Just add the callback
+- ✅ **Automatic token tracking** - Captures all LLM calls
+- ✅ **Multi-provider support** - OpenAI, Anthropic, any LangChain LLM
+- ✅ **Chain tracking** - Tracks entire chain executions
+- ✅ **Cost calculation** - Auto-calculates costs per model
+- ✅ **Prompt profitability** - Compare costs vs revenue
+- ✅ **OpenTelemetry compatible** - Standard observability
+
+## Advanced Usage
+
+### Track Custom Revenue
+
+```python
+# Track revenue for profitability analysis
+callback.track_revenue(
+    event_name="chat_completion",
+    revenue=0.50,  # What you charged the customer
+    metadata={"subscription_tier": "pro"}
+)
+```
+
+### Use with Agents
+
+```python
+from langchain.agents import initialize_agent, load_tools
+
+tools = load_tools(["serpapi", "llm-math"], llm=llm)
+agent = initialize_agent(
+    tools,
+    llm,
+    agent="zero-shot-react-description",
+    callbacks=[callback]  # Add callback here
+)
+
+# All agent steps auto-tracked!
+response = agent.run("What is 25% of 300?")
+```
+
+### Use with Sequential Chains
+
+```python
+from langchain.chains import SimpleSequentialChain
+
+# All chain steps tracked automatically
+overall_chain = SimpleSequentialChain(
+    chains=[chain1, chain2, chain3],
+    callbacks=[callback]
+)
+
+result = overall_chain.run(input_text)
+```
+
+## Configuration
+
+```python
+callback = AgentBillCallback(
+    api_key="agb_...",           # Required - get from dashboard
+    base_url="https://...",      # Required - your AgentBill instance
+    customer_id="customer-123",  # Optional - for multi-tenant apps
+    account_id="account-456",    # Optional - for account-level tracking
+    debug=True,                  # Optional - enable debug logging
+    batch_size=10,               # Optional - batch signals before sending
+    flush_interval=5.0           # Optional - flush interval in seconds
+)
+```
+
+## How It Works
+
+The callback hooks into LangChain's lifecycle:
+
+1. **on_llm_start** - Captures prompt, model, provider
+2. **on_llm_end** - Captures tokens, latency, response
+3. **on_llm_error** - Captures errors and retries
+4. **on_chain_start** - Tracks chain execution start
+5. **on_chain_end** - Tracks chain completion
+
+All data is sent to AgentBill via the `record-signals` API endpoint with proper authentication.
+
+## Supported Models
+
+Auto-cost calculation for:
+- OpenAI: GPT-4, GPT-4o, GPT-3.5-turbo, etc.
+- Anthropic: Claude 3.5 Sonnet, Claude 3 Opus, etc.
+- Any LangChain-compatible LLM
+
+## Troubleshooting
+
+### Not seeing data in dashboard?
+
+1. Check API key is correct
+2. Enable `debug=True` to see logs
+3. Verify `base_url` matches your instance
+4. Check network connectivity to AgentBill
+
+### Token counts are zero?
+
+- Some LLMs don't return token usage
+- Callback will estimate based on response length
+- OpenAI/Anthropic provide accurate counts
+
+## License
+
+MIT

agentbill_py_langchain-4.0.1/agentbill_py_langchain.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+setup.py
+agentbill_langchain/__init__.py
+agentbill_langchain/callback.py
+agentbill_py_langchain.egg-info/PKG-INFO
+agentbill_py_langchain.egg-info/SOURCES.txt
+agentbill_py_langchain.egg-info/dependency_links.txt
+agentbill_py_langchain.egg-info/requires.txt
+agentbill_py_langchain.egg-info/top_level.txt
+tests/test_callback.py

agentbill_py_langchain-4.0.1/agentbill_py_langchain.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agentbill_py_langchain-4.0.1/agentbill_py_langchain.egg-info/requires.txt

@@ -0,0 +1,8 @@
+langchain>=0.1.0
+requests>=2.28.0
+
+[anthropic]
+langchain-anthropic>=0.0.1
+
+[openai]
+langchain-openai>=0.0.1

agentbill_py_langchain-4.0.1/agentbill_py_langchain.egg-info/top_level.txt

@@ -0,0 +1 @@
+agentbill_langchain

agentbill_py_langchain-4.0.1/setup.cfg

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

agentbill_py_langchain-4.0.1/setup.py

@@ -0,0 +1,38 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="agentbill-py-langchain",
+    version="4.0.1",
+    author="AgentBill",
+    author_email="dominic@agentbill.io",
+    description="LangChain callback handler for automatic usage tracking and billing with AgentBill",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/Agent-Bill/langchain",
+    packages=find_packages(),
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+    ],
+    python_requires=">=3.8",
+    install_requires=[
+        "langchain>=0.1.0",
+        "requests>=2.28.0",
+    ],
+    extras_require={
+        "openai": ["langchain-openai>=0.0.1"],
+        "anthropic": ["langchain-anthropic>=0.0.1"],
+    },
+    keywords="langchain agentbill ai agent billing usage-tracking openai anthropic llm observability callbacks",
+)

agentbill_py_langchain-4.0.1/tests/test_callback.py

@@ -0,0 +1,121 @@
+"""Tests for AgentBill LangChain callback handler."""
+
+import pytest
+from unittest.mock import Mock, patch
+from agentbill_langchain import AgentBillCallback
+
+
+@pytest.fixture
+def callback():
+    """Create a callback instance for testing."""
+    return AgentBillCallback(
+        api_key="test-api-key",
+        base_url="https://test.agentbill.com",
+        customer_id="test-customer",
+        debug=False
+    )
+
+
+def test_callback_initialization(callback):
+    """Test callback is initialized correctly."""
+    assert callback is not None
+    assert callback.api_key == "test-api-key"
+    assert callback.base_url == "https://test.agentbill.com"
+    assert callback.customer_id == "test-customer"
+
+
+def test_callback_on_llm_start(callback):
+    """Test callback handles LLM start event."""
+    serialized = {"name": "OpenAI"}
+    prompts = ["Test prompt"]
+    
+    # Should not raise exception
+    callback.on_llm_start(serialized, prompts)
+
+
+def test_callback_on_llm_end(callback):
+    """Test callback handles LLM end event."""
+    response = Mock()
+    response.llm_output = {
+        "token_usage": {
+            "prompt_tokens": 10,
+            "completion_tokens": 20,
+            "total_tokens": 30
+        },
+        "model_name": "gpt-4"
+    }
+    
+    # Should not raise exception
+    callback.on_llm_end(response)
+
+
+def test_callback_on_llm_error(callback):
+    """Test callback handles LLM error event."""
+    error = Exception("Test error")
+    
+    # Should not raise exception
+    callback.on_llm_error(error)
+
+
+def test_callback_on_chain_start(callback):
+    """Test callback handles chain start event."""
+    serialized = {"name": "LLMChain"}
+    inputs = {"input": "test"}
+    
+    # Should not raise exception
+    callback.on_chain_start(serialized, inputs)
+
+
+def test_callback_on_chain_end(callback):
+    """Test callback handles chain end event."""
+    outputs = {"output": "test"}
+    
+    # Should not raise exception
+    callback.on_chain_end(outputs)
+
+
+def test_callback_on_tool_start(callback):
+    """Test callback handles tool start event."""
+    serialized = {"name": "Calculator"}
+    input_str = "2+2"
+    
+    # Should not raise exception
+    callback.on_tool_start(serialized, input_str)
+
+
+def test_callback_on_tool_end(callback):
+    """Test callback handles tool end event."""
+    output = "4"
+    
+    # Should not raise exception
+    callback.on_tool_end(output)
+
+
+@patch('requests.post')
+def test_callback_flush(mock_post, callback):
+    """Test callback flushes data correctly."""
+    mock_post.return_value.status_code = 200
+    
+    # Simulate some activity
+    callback.on_llm_start({"name": "OpenAI"}, ["test"])
+    
+    response = Mock()
+    response.llm_output = {
+        "token_usage": {
+            "prompt_tokens": 10,
+            "completion_tokens": 20,
+            "total_tokens": 30
+        },
+        "model_name": "gpt-4"
+    }
+    callback.on_llm_end(response)
+    
+    # Should not raise exception
+    callback.flush()
+
+
+def test_callback_context_manager(callback):
+    """Test callback works as context manager."""
+    with callback as cb:
+        assert cb is callback
+    # Should clean up properly