raw-agent 0.1.0__tar.gz

raw_agent-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

raw_agent-0.1.0/.python-version

@@ -0,0 +1 @@
+3.14

raw_agent-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Siddharth
+
+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.

raw_agent-0.1.0/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: raw-agent
+Version: 0.1.0
+Summary: A powerful and flexible LLM interface library for Gemini and other models.
+Project-URL: Homepage, https://github.com/siddharth200119/RAW
+Project-URL: Repository, https://github.com/siddharth200119/RAW
+Project-URL: Issues, https://github.com/siddharth200119/RAW/issues
+Author-email: Siddharth <siddharth@example.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.14
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: jsonschema>=4.26.0
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: opencv-python>=4.13.0.92
+Requires-Dist: pydantic>=2.12.5
+Description-Content-Type: text/markdown
+
+# RAW Project
+
+A powerful and flexible LLM interface library for Gemini and other models, designed for modern Python applications, featuring a robust Agent framework.
+
+## Features
+
+-   **Gemini Integration**: Seamless support for Google's Gemini models (default: `gemini-1.5-flash`).
+-   **Unified Interface**: Clean, consistent API for chat, completion, and tool usage.
+-   **Agent Framework**: Build autonomous agents with tool-calling capabilities.
+-   **Async Support**: Fully asynchronous implementation using `httpx` and `asyncio`.
+-   **Tool Calling**: Easy-to-use function calling/tool usage with schema generation.
+-   **Streaming**: Native support for streaming responses.
+
+## Installation
+
+```bash
+pip install raw
+```
+
+or with `uv`:
+
+```bash
+uv add raw
+```
+
+## Quick Start / Documentation
+
+### 1. Using LLMs
+
+The project supports LLMs via the `BaseLLM` interface. The primary implementation provided is `GeminiLLM`.
+
+#### Initialization
+
+To use `GeminiLLM`, you need a Google Gemini API key.
+
+```python
+import os
+from RAW.llms.gemini import GeminiLLM
+from RAW.utils import Logger
+
+# Check/Set API Key
+api_key = os.environ.get("GEMINI_API_KEY")
+if not api_key:
+    raise ValueError("GEMINI_API_KEY not set")
+
+# Optional: Configure Logger
+logger = Logger("MyLLM")
+
+# Initialize
+# Default model: gemini-1.5-flash (configurable via model argument)
+llm = GeminiLLM(api_key=api_key, logger=logger, model="gemini-1.5-flash")
+```
+
+#### Basic Chat
+
+You can interact with the LLM using the `chat` method, which accepts a list of `Message` objects.
+
+```python
+from RAW.modals import Message
+
+messages = [
+    Message(role="user", content="Hello, who are you?")
+]
+
+# Non-streaming
+response = await llm.chat(messages=messages)
+print(response.content)
+
+# Streaming
+async for chunk in await llm.chat(messages=messages, stream=True):
+    print(chunk.content)
+```
+
+### 2. Making Tools
+
+Tools allow the Agent to perform actions or retrieve information. A `Tool` consists of a name, description, parameters, and a python function.
+
+#### Define the Function
+
+Create an async function that performs the desired action.
+
+```python
+async def get_weather(location: str):
+    """Fetches weather for a given location."""
+    # Your logic here (e.g., API call)
+    return f"The weather in {location} is sunny."
+```
+
+#### Define the Tool Definition
+
+Wrap the function in a `Tool` object, specifying its schema using `ToolParam`.
+
+```python
+from RAW.modals import Tool
+from RAW.modals.tools import ToolParam
+
+weather_tool = Tool(
+    name="get_weather",
+    description="Get the weather for a specific location",
+    parameters=[
+        ToolParam(
+            name="location",
+            type="string",
+            description="City and State, e.g. New York, NY",
+            required=True
+        )
+    ],
+    function=get_weather
+)
+```
+
+### 3. Making an Agent
+
+The `Agent` orchestrates the interaction between the LLM, Tools, and the User. It manages the conversation history and tool execution loop.
+
+#### Initialization
+
+Combine the LLM and Tools into an Agent.
+
+```python
+from RAW.agent import Agent
+
+agent = Agent(
+    name="WeatherBot",
+    base_prompt="You are a helpful assistant that can check the weather.",
+    tools=[weather_tool], # List of Tool objects
+    llm=llm,              # The LLM instance
+    logger=logger         # Optional logger
+)
+```
+
+#### Running the Agent
+
+The agent is callable. You can run it in a loop to handle user input.
+
+```python
+user_input = "What is the weather in London?"
+
+# The agent returns a generator yielding chunks of the response
+async for chunk in agent(user_input, stream=True):
+    # 'chunk' can be a dictionary containing content or tool execution status
+    if isinstance(chunk, dict) and 'content' in chunk:
+        content_obj = chunk['content']
+        # content_obj might be a Message dump or a string
+        if isinstance(content_obj, dict) and 'content' in content_obj:
+             print(content_obj['content'], end="", flush=True)
+```
+
+### Full Example
+
+See `main.py` in the project root for a complete, runnable example of a Chatbot Agent.
+
+## License
+
+MIT

raw_agent-0.1.0/README.md

@@ -0,0 +1,155 @@
+# RAW Project
+
+A powerful and flexible LLM interface library for Gemini and other models, designed for modern Python applications, featuring a robust Agent framework.
+
+## Features
+
+-   **Gemini Integration**: Seamless support for Google's Gemini models (default: `gemini-1.5-flash`).
+-   **Unified Interface**: Clean, consistent API for chat, completion, and tool usage.
+-   **Agent Framework**: Build autonomous agents with tool-calling capabilities.
+-   **Async Support**: Fully asynchronous implementation using `httpx` and `asyncio`.
+-   **Tool Calling**: Easy-to-use function calling/tool usage with schema generation.
+-   **Streaming**: Native support for streaming responses.
+
+## Installation
+
+```bash
+pip install raw
+```
+
+or with `uv`:
+
+```bash
+uv add raw
+```
+
+## Quick Start / Documentation
+
+### 1. Using LLMs
+
+The project supports LLMs via the `BaseLLM` interface. The primary implementation provided is `GeminiLLM`.
+
+#### Initialization
+
+To use `GeminiLLM`, you need a Google Gemini API key.
+
+```python
+import os
+from RAW.llms.gemini import GeminiLLM
+from RAW.utils import Logger
+
+# Check/Set API Key
+api_key = os.environ.get("GEMINI_API_KEY")
+if not api_key:
+    raise ValueError("GEMINI_API_KEY not set")
+
+# Optional: Configure Logger
+logger = Logger("MyLLM")
+
+# Initialize
+# Default model: gemini-1.5-flash (configurable via model argument)
+llm = GeminiLLM(api_key=api_key, logger=logger, model="gemini-1.5-flash")
+```
+
+#### Basic Chat
+
+You can interact with the LLM using the `chat` method, which accepts a list of `Message` objects.
+
+```python
+from RAW.modals import Message
+
+messages = [
+    Message(role="user", content="Hello, who are you?")
+]
+
+# Non-streaming
+response = await llm.chat(messages=messages)
+print(response.content)
+
+# Streaming
+async for chunk in await llm.chat(messages=messages, stream=True):
+    print(chunk.content)
+```
+
+### 2. Making Tools
+
+Tools allow the Agent to perform actions or retrieve information. A `Tool` consists of a name, description, parameters, and a python function.
+
+#### Define the Function
+
+Create an async function that performs the desired action.
+
+```python
+async def get_weather(location: str):
+    """Fetches weather for a given location."""
+    # Your logic here (e.g., API call)
+    return f"The weather in {location} is sunny."
+```
+
+#### Define the Tool Definition
+
+Wrap the function in a `Tool` object, specifying its schema using `ToolParam`.
+
+```python
+from RAW.modals import Tool
+from RAW.modals.tools import ToolParam
+
+weather_tool = Tool(
+    name="get_weather",
+    description="Get the weather for a specific location",
+    parameters=[
+        ToolParam(
+            name="location",
+            type="string",
+            description="City and State, e.g. New York, NY",
+            required=True
+        )
+    ],
+    function=get_weather
+)
+```
+
+### 3. Making an Agent
+
+The `Agent` orchestrates the interaction between the LLM, Tools, and the User. It manages the conversation history and tool execution loop.
+
+#### Initialization
+
+Combine the LLM and Tools into an Agent.
+
+```python
+from RAW.agent import Agent
+
+agent = Agent(
+    name="WeatherBot",
+    base_prompt="You are a helpful assistant that can check the weather.",
+    tools=[weather_tool], # List of Tool objects
+    llm=llm,              # The LLM instance
+    logger=logger         # Optional logger
+)
+```
+
+#### Running the Agent
+
+The agent is callable. You can run it in a loop to handle user input.
+
+```python
+user_input = "What is the weather in London?"
+
+# The agent returns a generator yielding chunks of the response
+async for chunk in agent(user_input, stream=True):
+    # 'chunk' can be a dictionary containing content or tool execution status
+    if isinstance(chunk, dict) and 'content' in chunk:
+        content_obj = chunk['content']
+        # content_obj might be a Message dump or a string
+        if isinstance(content_obj, dict) and 'content' in content_obj:
+             print(content_obj['content'], end="", flush=True)
+```
+
+### Full Example
+
+See `main.py` in the project root for a complete, runnable example of a Chatbot Agent.
+
+## License
+
+MIT

raw_agent-0.1.0/main.py

@@ -0,0 +1,102 @@
+import asyncio
+import os
+from RAW.agent import Agent
+from RAW.llms.gemini import GeminiLLM
+from RAW.modals import Tool
+from RAW.modals.tools import ToolParam
+from RAW.utils import Logger
+
+# Example tool
+async def get_weather(location: str):
+    """Get the weather for a location."""
+    # Mock weather data
+    return f"The weather in {location} is sunny with a temperature of 25°C."
+
+async def main():
+    api_key = os.environ.get("GEMINI_API_KEY")
+    if not api_key:
+        print("Please set GEMINI_API_KEY environment variable.")
+        return
+
+    import logging
+    log_level_str = os.environ.get("LOG_LEVEL", "INFO").upper()
+    log_level = getattr(logging, log_level_str, logging.INFO)
+    logger = Logger("Chatbot", level=log_level)
+    
+    # Initialize LLM
+    model_name = os.environ.get("GEMINI_MODEL", "gemini-2.5-flash-lite")
+    llm = GeminiLLM(api_key=api_key, logger=logger, model=model_name)
+
+    # Initialize Tools
+    weather_tool = Tool(
+        name="get_weather",
+        description="Get the weather for a specific location",
+        parameters=[
+            ToolParam(name="location", type="string", description="The city and state, e.g. San Francisco, CA", required=True)
+        ],
+        function=get_weather
+    )
+    
+    # Initialize Agent
+    agent = Agent(
+        name="WeatherBot",
+        base_prompt="You are a helpful weather assistant.",
+        tools=[weather_tool],
+        llm=llm,
+        logger=logger
+    )
+
+    print("Chatbot started! Type 'exit' to quit.")
+    
+    while True:
+        user_input = input("You: ")
+        if user_input.lower() in ["exit", "quit"]:
+            break
+            
+        print("Bot: ", end="", flush=True)
+        async for chunk in agent(user_input, stream=True):
+            if isinstance(chunk, dict):
+                if "content" in chunk:
+                    content = chunk["content"]
+                    if isinstance(content, dict): # Message object dumped
+                         # Skip full message dumps, we want the stream chunks if possible or just final text
+                         pass
+                    elif isinstance(content, str): # Tool response or error
+                         # print(content) # Maybe don't print tool output directly to user
+                         pass
+            else:
+                 pass # String chunks ? Agent yield dicts.
+                 
+            # Agent yields:
+            # {"agent_name": name, "content": chunk} where chunk is Message.dump() or str (tool response)
+            # wait, agent.py yields:
+            # 1. {"agent_name": self.name, 'content': chunk.model_dump()} (if Message)
+            # 2. {"agent_name": self.name, 'content': chunk} (if str - tool response)
+            
+            # Streaming from LLM yields Message objects with partial content?
+            # execute_stream yields Message objects constructed from chunks. 
+            # Actually execute_stream yields:
+            # 1. Message (partial content)
+            # 2. Dict (tool call)
+            # 3. Dict (tool response)
+            
+            # Agent.__call__ wraps these:
+            # If chunk is Message -> yields dict with content=chunk.dump()
+            # If chunk is other -> yields dict with content=chunk
+            
+            # So if we want to print the token stream:
+            # The Agent logic in execute_stream accumulates content and yields a Message for each chunk?
+            # No.
+            # `yield Message(role="assistant", content=response.content ...)`
+            # So it yields a Message object for EACH chunk of text.
+            
+            if isinstance(chunk, dict) and "content" in chunk:
+                content_obj = chunk["content"]
+                if isinstance(content_obj, dict) and "content" in content_obj and content_obj["content"]:
+                     # It's a message dump
+                     print(content_obj["content"], end="", flush=True)
+
+        print() # Newline after response
+
+if __name__ == "__main__":
+    asyncio.run(main())

raw_agent-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "raw-agent"
+version = "0.1.0"
+description = "A powerful and flexible LLM interface library for Gemini and other models."
+readme = "README.md"
+requires-python = ">=3.14"
+authors = [
+    { name = "Siddharth", email = "siddharth@example.com" }
+]
+license = "MIT"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.14",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "httpx>=0.28.1",
+    "jsonschema>=4.26.0",
+    "opencv-python>=4.13.0.92",
+    "pydantic>=2.12.5",
+    "numpy>=2.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/siddharth200119/RAW"
+Repository = "https://github.com/siddharth200119/RAW"
+Issues = "https://github.com/siddharth200119/RAW/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/RAW"]
+[dependency-groups]
+dev = [
+    "mypy>=1.19.1",
+    "pytest>=9.0.2",
+    "ruff>=0.15.0",
+    "twine>=6.2.0",
+    "pytest-asyncio>=0.23.0",
+]
+[tool.pytest.ini_options]
+pythonpath = [".", "src"]
+asyncio_mode = "auto"

raw_agent-0.1.0/src/RAW/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"