Metadata-Version: 2.4
Name: rusted_chain
Version: 1.1.0
Classifier: Programming Language :: Rust
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Programming Language :: Python :: Implementation :: PyPy
Requires-Dist: langchain-core>=1.1.0
Summary: LangChain like python library written in rust
Keywords: langchain,rust,agents,bindings
Author-email: Bhuwan Joshi <kanhajsh@gmail.com>
Requires-Python: >=3.7
Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
Project-URL: Homepage, https://github.com/JoshiBhuwan/rusted-chain
Project-URL: Source, https://github.com/JoshiBhuwan/rusted-chain
Project-URL: Issues, https://github.com/JoshiBhuwan/rusted-chain/issues

# Rusted Chain

Rusted Chain is a Rust-powered LLM agent framework for Python. It combines the performance of Rust with the usability of Python, providing a LangChain-compatible API for building AI agents.

## Features

*   **Rust Core**: Backend implemented in Rust using `pyo3`.
*   **Multi-Model Support**: Supports Gemini, OpenAI, and Claude.
*   **LangChain Compatible**: Accepts standard LangChain tools and `@tool` decorators.
*   **Auto-Execution Loop**: Handles tool calling and execution automatically.
*   **Simple API**: Straightforward interface for creating agents and tools.

## Installation

```bash
pip install rusted-chain
```

## Quick Start

### Basic Usage

```python
from rusted_chain import GeminiModel, OpenAIModel, ClaudeModel

# Initialize an agent
agent = GeminiModel(api_key="your-api-key")

# Simple text generation
response = agent.invoke("Tell me a joke about Rust.")
print(response.text)
```

### Using Tools

You can pass Python functions directly. `rusted-chain` handles schema generation and execution.

```python
from rusted_chain import GeminiModel

def get_weather(city: str) -> str:
    """Get the current weather for a city."""
    return f"The weather in {city} is sunny and 25°C."

# Create agent with tools
agent = GeminiModel(tools=[get_weather])

# Run the agent
result = agent.run("What's the weather like in Tokyo?")
print(result)
# Output: "The weather in Tokyo is sunny and 25°C."
```

### Using LangChain Tools

You can also use existing LangChain tools or the `@tool` decorator.

```python
from langchain_core.tools import tool
from rusted_chain import OpenAIModel

@tool
def multiply(a: int, b: int) -> int:
    """Multiplies two numbers."""
    return a * b

agent = OpenAIModel(tools=[multiply])

result = agent.run("What is 123 * 456?")
print(result)
```

## Supported Models

| Class | Provider | Env Variable |
|-------|----------|--------------|
| `GeminiModel` | Google Gemini | `GOOGLE_API_KEY` |
| `OpenAIModel` | OpenAI (GPT-4, etc.) | `OPENAI_API_KEY` |
| `ClaudeModel` | Anthropic Claude | `ANTHROPIC_API_KEY` |

## Advanced Usage

### Manual Tool Control

Use `invoke()` to get the raw response (text or tool call) without auto-execution.

```python
response = agent.invoke("Call my_tool")

if response.is_tool_call:
    print(f"Tool: {response.tool_call.name}")
    print(f"Args: {response.tool_call.args}")
else:
    print(response.text)
```

## Performance benchmark (test_perf.py)

A small benchmarking script is included at `test_perf.py` to compare the request/response latency of `rusted_chain` vs a LangChain-based client when calling the Google Gemini model (the repository author used `gemini-2.5-flash` for tests).

```bash
pip install langchain-google-genai python-dotenv
```

How to run

* Optional environment variables used by the script:
    * `RC_BENCH_WARMUP` — set to `true`/`false` (default: `true`) to perform warm-up calls before measurements.
    * `RC_BENCH_REPEATS` — number of timed repetitions (default: `4`).

Example usage (from repo root)

```bash
# set API key and run the benchmark
export GOOGLE_API_KEY="your-google-api-key"
python test_perf.py
```

## License

MIT

