agentready-sdk 0.3.0__tar.gz

agentready_sdk-0.3.0/PKG-INFO

@@ -0,0 +1,214 @@
+Metadata-Version: 2.4
+Name: agentready-sdk
+Version: 0.3.0
+Summary: Cut your AI token costs by 40-60%. Drop-in proxy for OpenAI, LangChain, LlamaIndex, CrewAI.
+Author-email: AgentReady <christalingx@gmail.com>
+License: MIT
+Project-URL: Homepage, https://agentready.cloud
+Project-URL: Documentation, https://agentready.cloud/docs/quickstart
+Project-URL: Repository, https://github.com/christianbragliasitibt/agentready
+Keywords: llm,tokens,openai,compression,langchain,llamaindex,crewai,ai,cost-reduction,mcp,proxy
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+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
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.24.0
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == "openai"
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.1.0; extra == "langchain"
+Provides-Extra: llamaindex
+Requires-Dist: llama-index-core>=0.10.0; extra == "llamaindex"
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.28.0; extra == "crewai"
+Provides-Extra: all
+Requires-Dist: openai>=1.0.0; extra == "all"
+Requires-Dist: langchain-core>=0.1.0; extra == "all"
+Requires-Dist: llama-index-core>=0.10.0; extra == "all"
+Requires-Dist: crewai>=0.28.0; extra == "all"
+
+# AgentReady — Python SDK
+
+**Cut AI token costs by 40-60%.** Drop-in proxy for OpenAI, LangChain, LlamaIndex, CrewAI.
+
+[![PyPI](https://img.shields.io/pypi/v/agentready.svg)](https://pypi.org/project/agentready/)
+[![Python](https://img.shields.io/pypi/pyversions/agentready.svg)](https://pypi.org/project/agentready/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+
+## Install
+
+```bash
+pip install agentready
+```
+
+## Quick Start — Drop-in Proxy (Recommended)
+
+Just swap your `base_url`. **Zero code changes** to your existing OpenAI calls:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://agentready.cloud/v1",   # ← only change needed
+    api_key="ak_...",                          # your AgentReady key
+    default_headers={
+        "X-Upstream-API-Key": "sk-...",        # your OpenAI key
+    },
+)
+
+# Everything works exactly like before — but 40-60% cheaper
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": your_long_prompt}],
+)
+```
+
+### One-liner Helper
+
+```python
+import agentready
+
+client = agentready.openai("ak_...", upstream_key="sk-...")
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "Hello!"}],
+)
+```
+
+### Async Client
+
+```python
+client = agentready.create_client("ak_...", upstream_key="sk-...", async_client=True)
+response = await client.chat.completions.create(...)
+```
+
+## Method 2 — Monkey-Patch
+
+Patch all OpenAI/Anthropic calls globally with two lines:
+
+```python
+from agentready import patch_openai
+patch_openai(api_key="ak_...")
+
+# All existing OpenAI code is now compressed automatically
+from openai import OpenAI
+client = OpenAI()
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": your_long_prompt}],
+)
+```
+
+Or patch everything at once:
+
+```python
+import agentready
+agentready.api_key = "ak_..."
+agentready.auto()  # patches OpenAI + Anthropic
+```
+
+## Method 3 — Manual Compression
+
+For fine-grained control:
+
+```python
+import agentready
+agentready.api_key = "ak_..."
+
+result = agentready.compress("Your long prompt text here...")
+print(result.text)              # compressed text
+print(result.tokens_saved)      # 1,247
+print(result.reduction_percent) # 52.3
+print(result.savings_usd)       # 0.0374
+```
+
+## Framework Integrations
+
+### LangChain
+
+```python
+from agentready.integrations.langchain import TokenCutCallbackHandler
+from langchain_openai import ChatOpenAI
+
+handler = TokenCutCallbackHandler(api_key="ak_...")
+llm = ChatOpenAI(model="gpt-4o", callbacks=[handler])
+response = llm.invoke("Your very long prompt here...")
+```
+
+### LlamaIndex
+
+```python
+from agentready.integrations.llamaindex import TokenCutPostprocessor
+
+postprocessor = TokenCutPostprocessor(api_key="ak_...")
+query_engine = index.as_query_engine(
+    node_postprocessors=[postprocessor]
+)
+```
+
+### CrewAI
+
+```python
+from agentready.integrations.crewai import create_crewai_llm
+from crewai import Agent, Task, Crew
+
+llm = create_crewai_llm(
+    agentready_key="ak_...",
+    upstream_key="sk-...",
+    model="gpt-4o",
+)
+
+agent = Agent(
+    role="Researcher",
+    goal="Research AI trends",
+    backstory="Expert AI researcher.",
+    llm=llm,
+)
+```
+
+## How It Works
+
+AgentReady's proxy sits between your code and OpenAI. Every request is:
+
+1. **Compressed** — redundant phrasing removed, verbose text condensed
+2. **Forwarded** — sent to OpenAI with your upstream key
+3. **Returned** — response comes back unchanged
+
+Code blocks, URLs, numbers, and key terms are always preserved.
+
+## Configuration
+
+```python
+# Proxy mode — compression level via header
+client = agentready.openai(
+    "ak_...",
+    upstream_key="sk-...",
+    compression_level="aggressive",  # "light", "standard", "aggressive"
+)
+
+# Patch mode — configuration via arguments
+agentready.auto(
+    level="medium",
+    preserve_code=True,
+    min_tokens=100,
+)
+```
+
+## Pricing
+
+**Beta — Free unlimited usage.** After beta: pay-per-token, ~60% less than direct API costs.
+
+Get your API key at [agentready.cloud](https://agentready.cloud)
+
+## License
+
+MIT — [AgentReady](https://agentready.cloud)

agentready_sdk-0.3.0/README.md

@@ -0,0 +1,176 @@
+# AgentReady — Python SDK
+
+**Cut AI token costs by 40-60%.** Drop-in proxy for OpenAI, LangChain, LlamaIndex, CrewAI.
+
+[![PyPI](https://img.shields.io/pypi/v/agentready.svg)](https://pypi.org/project/agentready/)
+[![Python](https://img.shields.io/pypi/pyversions/agentready.svg)](https://pypi.org/project/agentready/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+
+## Install
+
+```bash
+pip install agentready
+```
+
+## Quick Start — Drop-in Proxy (Recommended)
+
+Just swap your `base_url`. **Zero code changes** to your existing OpenAI calls:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://agentready.cloud/v1",   # ← only change needed
+    api_key="ak_...",                          # your AgentReady key
+    default_headers={
+        "X-Upstream-API-Key": "sk-...",        # your OpenAI key
+    },
+)
+
+# Everything works exactly like before — but 40-60% cheaper
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": your_long_prompt}],
+)
+```
+
+### One-liner Helper
+
+```python
+import agentready
+
+client = agentready.openai("ak_...", upstream_key="sk-...")
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "Hello!"}],
+)
+```
+
+### Async Client
+
+```python
+client = agentready.create_client("ak_...", upstream_key="sk-...", async_client=True)
+response = await client.chat.completions.create(...)
+```
+
+## Method 2 — Monkey-Patch
+
+Patch all OpenAI/Anthropic calls globally with two lines:
+
+```python
+from agentready import patch_openai
+patch_openai(api_key="ak_...")
+
+# All existing OpenAI code is now compressed automatically
+from openai import OpenAI
+client = OpenAI()
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": your_long_prompt}],
+)
+```
+
+Or patch everything at once:
+
+```python
+import agentready
+agentready.api_key = "ak_..."
+agentready.auto()  # patches OpenAI + Anthropic
+```
+
+## Method 3 — Manual Compression
+
+For fine-grained control:
+
+```python
+import agentready
+agentready.api_key = "ak_..."
+
+result = agentready.compress("Your long prompt text here...")
+print(result.text)              # compressed text
+print(result.tokens_saved)      # 1,247
+print(result.reduction_percent) # 52.3
+print(result.savings_usd)       # 0.0374
+```
+
+## Framework Integrations
+
+### LangChain
+
+```python
+from agentready.integrations.langchain import TokenCutCallbackHandler
+from langchain_openai import ChatOpenAI
+
+handler = TokenCutCallbackHandler(api_key="ak_...")
+llm = ChatOpenAI(model="gpt-4o", callbacks=[handler])
+response = llm.invoke("Your very long prompt here...")
+```
+
+### LlamaIndex
+
+```python
+from agentready.integrations.llamaindex import TokenCutPostprocessor
+
+postprocessor = TokenCutPostprocessor(api_key="ak_...")
+query_engine = index.as_query_engine(
+    node_postprocessors=[postprocessor]
+)
+```
+
+### CrewAI
+
+```python
+from agentready.integrations.crewai import create_crewai_llm
+from crewai import Agent, Task, Crew
+
+llm = create_crewai_llm(
+    agentready_key="ak_...",
+    upstream_key="sk-...",
+    model="gpt-4o",
+)
+
+agent = Agent(
+    role="Researcher",
+    goal="Research AI trends",
+    backstory="Expert AI researcher.",
+    llm=llm,
+)
+```
+
+## How It Works
+
+AgentReady's proxy sits between your code and OpenAI. Every request is:
+
+1. **Compressed** — redundant phrasing removed, verbose text condensed
+2. **Forwarded** — sent to OpenAI with your upstream key
+3. **Returned** — response comes back unchanged
+
+Code blocks, URLs, numbers, and key terms are always preserved.
+
+## Configuration
+
+```python
+# Proxy mode — compression level via header
+client = agentready.openai(
+    "ak_...",
+    upstream_key="sk-...",
+    compression_level="aggressive",  # "light", "standard", "aggressive"
+)
+
+# Patch mode — configuration via arguments
+agentready.auto(
+    level="medium",
+    preserve_code=True,
+    min_tokens=100,
+)
+```
+
+## Pricing
+
+**Beta — Free unlimited usage.** After beta: pay-per-token, ~60% less than direct API costs.
+
+Get your API key at [agentready.cloud](https://agentready.cloud)
+
+## License
+
+MIT — [AgentReady](https://agentready.cloud)

agentready_sdk-0.3.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agentready-sdk"
+version = "0.3.0"
+description = "Cut your AI token costs by 40-60%. Drop-in proxy for OpenAI, LangChain, LlamaIndex, CrewAI."
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+authors = [{name = "AgentReady", email = "christalingx@gmail.com"}]
+keywords = ["llm", "tokens", "openai", "compression", "langchain", "llamaindex", "crewai", "ai", "cost-reduction", "mcp", "proxy"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "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",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "httpx>=0.24.0",
+]
+
+[project.optional-dependencies]
+openai = ["openai>=1.0.0"]
+langchain = ["langchain-core>=0.1.0"]
+llamaindex = ["llama-index-core>=0.10.0"]
+crewai = ["crewai>=0.28.0"]
+all = ["openai>=1.0.0", "langchain-core>=0.1.0", "llama-index-core>=0.10.0", "crewai>=0.28.0"]
+
+[project.urls]
+Homepage = "https://agentready.cloud"
+Documentation = "https://agentready.cloud/docs/quickstart"
+Repository = "https://github.com/christianbragliasitibt/agentready"
+
+[tool.setuptools.packages.find]
+where = ["src"]

agentready_sdk-0.3.0/setup.cfg

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

agentready_sdk-0.3.0/src/agentready/__init__.py

@@ -0,0 +1,109 @@
+"""
+AgentReady — Cut your AI token costs by 40-60%.
+
+Drop-in proxy for OpenAI, Anthropic, LangChain, LlamaIndex, CrewAI.
+
+Quick Start (recommended — just swap base_url):
+    from openai import OpenAI
+    client = OpenAI(
+        base_url="https://agentready.cloud/v1",
+        api_key="ak_...",  # your AgentReady API key
+        default_headers={"X-Upstream-API-Key": "sk-..."},  # your OpenAI key
+    )
+    # That's it! All calls are now compressed automatically.
+
+One-liner:
+    import agentready
+    client = agentready.openai("ak_...", upstream_key="sk-...")
+
+Patch mode (monkey-patch existing code):
+    import agentready
+    agentready.api_key = "ak_..."
+    agentready.auto()  # patches OpenAI & Anthropic globally
+
+Manual compression:
+    import agentready
+    agentready.api_key = "ak_..."
+    result = agentready.compress("Your long prompt here...")
+"""
+
+from agentready.client import TokenCutClient, CompressResult
+from agentready.patch import auto, unpatch, patch_openai, patch_anthropic
+from agentready.proxy import openai, create_client
+
+__version__ = "0.3.0"
+__all__ = [
+    "api_key",
+    "auto",
+    "unpatch",
+    "patch_openai",
+    "patch_anthropic",
+    "openai",
+    "create_client",
+    "compress",
+    "compress_async",
+    "CompressResult",
+]
+
+# ── Module-level API key ─────────────────────────────────────────────
+api_key: str | None = None
+
+# ── Module-level client (lazy) ───────────────────────────────────────
+_client: TokenCutClient | None = None
+
+
+def _get_client() -> TokenCutClient:
+    global _client
+    if _client is None or _client.api_key != api_key:
+        if not api_key:
+            raise ValueError(
+                "agentready.api_key is not set. "
+                "Get your API key at https://agentready.cloud/dashboard/api-keys"
+            )
+        _client = TokenCutClient(api_key=api_key)
+    return _client
+
+
+def compress(
+    text: str,
+    level: str = "medium",
+    preserve_code: bool = True,
+    preserve_urls: bool = True,
+    target_model: str = "gpt-4",
+) -> CompressResult:
+    """Compress text using TokenCut.
+
+    Args:
+        text: The text to compress.
+        level: Compression level — "light", "medium", or "aggressive".
+        preserve_code: Keep code blocks intact.
+        preserve_urls: Keep URLs intact.
+        target_model: Target LLM model for cost estimation.
+
+    Returns:
+        CompressResult with compressed text and stats.
+    """
+    return _get_client().compress(
+        text=text,
+        level=level,
+        preserve_code=preserve_code,
+        preserve_urls=preserve_urls,
+        target_model=target_model,
+    )
+
+
+async def compress_async(
+    text: str,
+    level: str = "medium",
+    preserve_code: bool = True,
+    preserve_urls: bool = True,
+    target_model: str = "gpt-4",
+) -> CompressResult:
+    """Async version of compress."""
+    return await _get_client().compress_async(
+        text=text,
+        level=level,
+        preserve_code=preserve_code,
+        preserve_urls=preserve_urls,
+        target_model=target_model,
+    )

agentready_sdk-0.3.0/src/agentready/client.py

@@ -0,0 +1,123 @@
+"""TokenCut API client."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+import httpx
+
+API_BASE = "https://agentready.cloud/api/v1"
+
+
+@dataclass
+class CompressResult:
+    """Result of a TokenCut compression."""
+
+    text: str
+    original_tokens: int
+    compressed_tokens: int
+    tokens_saved: int
+    reduction_percent: float
+    original_cost_usd: float
+    compressed_cost_usd: float
+    savings_usd: float
+    processing_time_ms: float
+    credits_consumed: int
+    credits_remaining: int
+
+    @property
+    def ratio(self) -> float:
+        """Compression ratio (0-1)."""
+        if self.original_tokens == 0:
+            return 0.0
+        return self.tokens_saved / self.original_tokens
+
+
+class TokenCutClient:
+    """Low-level TokenCut API client."""
+
+    def __init__(self, api_key: str, base_url: str = API_BASE, timeout: float = 30.0):
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+    def _headers(self) -> dict:
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "User-Agent": "agentready-python/0.3.0",
+        }
+
+    def _parse_response(self, data: dict) -> CompressResult:
+        if not data.get("success"):
+            raise TokenCutError(data.get("error", "Unknown error"))
+
+        stats = data["data"]["stats"]
+        return CompressResult(
+            text=data["data"]["compressed_text"],
+            original_tokens=stats["original_tokens"],
+            compressed_tokens=stats["compressed_tokens"],
+            tokens_saved=stats["tokens_saved"],
+            reduction_percent=stats["reduction_percent"],
+            original_cost_usd=stats.get("original_cost_usd", 0),
+            compressed_cost_usd=stats.get("compressed_cost_usd", 0),
+            savings_usd=stats.get("savings_usd", 0),
+            processing_time_ms=stats.get("processing_time_ms", 0),
+            credits_consumed=data.get("credits_consumed", 0),
+            credits_remaining=data.get("credits_remaining", 0),
+        )
+
+    def compress(
+        self,
+        text: str,
+        level: str = "medium",
+        preserve_code: bool = True,
+        preserve_urls: bool = True,
+        target_model: str = "gpt-4",
+    ) -> CompressResult:
+        """Compress text synchronously."""
+        with httpx.Client(timeout=self.timeout) as client:
+            response = client.post(
+                f"{self.base_url}/tools/tokencut",
+                headers=self._headers(),
+                json={
+                    "text": text,
+                    "level": level,
+                    "preserve_code": preserve_code,
+                    "preserve_urls": preserve_urls,
+                    "target_model": target_model,
+                },
+            )
+            response.raise_for_status()
+            return self._parse_response(response.json())
+
+    async def compress_async(
+        self,
+        text: str,
+        level: str = "medium",
+        preserve_code: bool = True,
+        preserve_urls: bool = True,
+        target_model: str = "gpt-4",
+    ) -> CompressResult:
+        """Compress text asynchronously."""
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            response = await client.post(
+                f"{self.base_url}/tools/tokencut",
+                headers=self._headers(),
+                json={
+                    "text": text,
+                    "level": level,
+                    "preserve_code": preserve_code,
+                    "preserve_urls": preserve_urls,
+                    "target_model": target_model,
+                },
+            )
+            response.raise_for_status()
+            return self._parse_response(response.json())
+
+
+class TokenCutError(Exception):
+    """Error from the TokenCut API."""
+
+    pass

agentready_sdk-0.3.0/src/agentready/integrations/__init__.py

@@ -0,0 +1 @@
+"""AgentReady integrations for popular LLM frameworks."""