langchain asi1

.gitignore

@@ -2,6 +2,5 @@
 .env
 __pycache__/
 /venv/
-langchain-asi-main/
-langchain-asi/
+
 *.json

langchain-asi/.gitignore

@@ -0,0 +1,2 @@
+.env
+asi-env

langchain-asi/README.md

@@ -0,0 +1,262 @@
+# langchain-asi
+# LangChain ASI1 Integration
+
+A lightweight, easy-to-use integration package that connects ASI1's API with the LangChain ecosystem.
+
+## Overview
+
+This package provides seamless integration between ASI1's API and LangChain, allowing you to use ASI1's language models with LangChain's frameworks, agents, and tools. The integration is designed to be a drop-in replacement for other LLM providers like OpenAI and Anthropic, taking advantage of ASI1's OpenAI-compatible API.
+
+## Features
+
+- **Simple Integration**: Easily swap ASI1 models into your existing LangChain applications
+- **Conversation Support**: Full support for multi-turn conversations with memory
+- **System Instructions**: Control model behavior with system messages
+- **Agent Support**: Create LangChain agents powered by ASI1 models
+- **Tool Integration**: Connect ASI1 models with LangChain tools and utilities
+- **Parameter Control**: Customize temperature, max tokens, and other model parameters
+- **Error Handling**: Robust error handling for API communication
+
+## Installation
+
+```bash
+# From source
+git clone https://github.com/yourusername/langchain-asi.git
+cd langchain-asi
+pip install -e .
+
+# Or when published on PyPI
+pip install langchain-asi
+```
+## Quick Start
+
+### Basic Usage
+
+```python
+from langchain_asi import ASI1ChatModel
+from dotenv import load_dotenv
+
+# Load API key from .env file (recommended)
+load_dotenv()
+
+# Initialize the model
+llm = ASI1ChatModel()
+
+# Simple query
+response = llm.invoke("What are the three laws of robotics?")
+print(response.content)
+```
+
+### Conversation with System Message
+
+```python
+from langchain_asi import ASI1ChatModel
+from langchain.schema import HumanMessage, SystemMessage, AIMessage
+
+# Initialize with custom parameters
+llm = ASI1ChatModel(
+    model_name="asi1-mini",
+    temperature=0.3,
+    max_tokens=2000
+)
+
+# Create a conversation with a system message
+messages = [
+    SystemMessage(content="You are a helpful assistant that always responds in rhymes."),
+    HumanMessage(content="Tell me about artificial intelligence.")
+]
+
+response = llm.invoke(messages)
+print(response.content)
+
+# Continue the conversation
+messages.append(response)
+messages.append(HumanMessage(content="What are its potential risks?"))
+response = llm.invoke(messages)
+print(response.content)
+```
+## Working with LangChain Chains
+
+```python
+from langchain_asi import ASI1ChatModel
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+
+# Initialize the model
+llm = ASI1ChatModel()
+
+# Create a simple prompt template
+template = "Write a short {style} poem about {topic}."
+prompt = PromptTemplate(template=template, input_variables=["style", "topic"])
+
+# Create a chain
+chain = LLMChain(llm=llm, prompt=prompt)
+
+# Run the chain
+result = chain.run(style="haiku", topic="artificial intelligence")
+print(result)
+```
+
+## Creating Agents
+
+### Simple Agent with Tools
+
+```python
+from langchain_asi import ASI1ChatModel, create_asi_agent
+from langchain.tools import BaseTool
+from typing import List
+
+# Define a calculator tool
+class Calculator(BaseTool):
+    name: str = "calculator"
+    description: str = "Useful for performing mathematical calculations"
+    
+    def _run(self, query: str) -> str:
+        try:
+            return str(eval(query))
+        except Exception as e:
+            return f"Error: {str(e)}"
+    
+    def _arun(self, query: str):
+        raise NotImplementedError("This tool does not support async")
+
+# Create a list of tools
+tools = [Calculator()]
+
+# Create an agent using the utility function
+agent = create_asi_agent(
+    tools=tools,
+    system_prompt="You are a helpful assistant that's good at math.",
+    temperature=0.2
+)
+
+# Use the agent
+result = agent.run("If I have 25 apples and give 7 to my friend, then eat 3 myself, how many do I have left?")
+print(result)
+```
+
+## API Configuration
+
+### Environment Variables
+
+The recommended way to set your ASI1 API key is via environment variables:
+
+```bash
+export ASI1_API_KEY=your_api_key_here
+```
+
+Or in your Python code:
+
+```python
+import os
+os.environ["ASI1_API_KEY"] = "your_api_key_here"
+```
+
+### Using .env Files
+
+For development, you can store your API key in a `.env` file:
+
+```
+ASI1_API_KEY=your_api_key_here
+```
+
+Then load it with:
+
+```python
+from dotenv import load_dotenv
+load_dotenv()
+```
+
+### Direct Parameter
+
+You can also pass the API key directly when initializing the model:
+
+```python
+llm = ASI1ChatModel(api_key="your_api_key_here")
+```
+
+## Advanced Configuration
+
+### Custom API Base URL
+
+If you need to use a different API endpoint:
+
+```python
+llm = ASI1ChatModel(
+    api_base="https://your-custom-endpoint.com/v1"
+)
+```
+
+### Model Parameters
+
+Configure various model parameters:
+
+```python
+llm = ASI1ChatModel(
+    model_name="asi1-mini",  # Model name
+    temperature=0.7,         # Randomness (0-1)
+    max_tokens=8000          # Maximum response length
+)
+```
+
+## Integration with LangGraph
+
+For more complex agent workflows, you can integrate ASI1 models with LangGraph:
+
+```python
+from langgraph.prebuilt import create_react_agent
+from langgraph.checkpoint.memory import MemorySaver
+from langchain_asi import ASI1ChatModel
+from langchain_core.tools import tool
+
+# Define a tool
+@tool
+def search(query: str):
+    """Search for information."""
+    if "weather" in query.lower():
+        return "It's currently sunny and 22°C."
+    return "No specific information found."
+
+# Initialize the ASI1 model
+model = ASI1ChatModel(temperature=0)
+
+# Initialize memory
+checkpointer = MemorySaver()
+
+# Create a LangGraph agent
+app = create_react_agent(model, [search], checkpointer=checkpointer)
+
+# Use the agent
+result = app.invoke(
+    {"messages": [{"role": "user", "content": "What's the weather today?"}]},
+    config={"configurable": {"thread_id": "unique-thread-id"}}
+)
+
+# Get the final response
+print(result["messages"][-1].content)
+```
+
+## Limitations
+
+- The current implementation does not support native function calling (available in some other LLMs)
+- Streaming responses are not yet implemented
+- Some advanced LangChain features may require additional configuration
+
+## Troubleshooting
+
+### API Key Issues
+
+If you encounter authentication errors, check that your API key is:
+- Correctly set in your environment or passed to the model
+- Valid and active in your ASI1 account
+
+### Agent Parsing Errors
+
+When using agents, you may see parsing errors. These can often be resolved by:
+- Setting `handle_parsing_errors=True` when creating the agent
+- Using the `ZERO_SHOT_REACT_DESCRIPTION` agent type which is more forgiving
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+

langchain-asi/examples/test_agent.py

@@ -0,0 +1,84 @@
+# test_agent.py
+from dotenv import load_dotenv
+load_dotenv()
+
+from langchain_asi import ASI1ChatModel
+from langchain.agents import AgentType, initialize_agent
+from langchain.tools import BaseTool
+from typing import List
+
+from typing import Optional, Type
+from langchain_asi import ASI1ChatModel
+from langchain.agents import AgentType, initialize_agent
+from langchain.tools import BaseTool
+from typing import List
+
+# Update the Calculator class with type annotations
+class Calculator(BaseTool):
+    name: str = "calculator"  # Add type annotation here
+    description: str = "Useful for when you need to calculate mathematical expressions"
+    
+    def _run(self, query: str) -> str:
+        try:
+            return str(eval(query))
+        except Exception as e:
+            return f"Error: {str(e)}"
+    
+    def _arun(self, query: str):
+        raise NotImplementedError("This tool does not support async")
+
+# Do the same for WeatherTool
+class WeatherTool(BaseTool):
+    name: str = "weather"  # Add type annotation here
+    description: str = "Get the weather for a specific location"
+    
+    def _run(self, location: str) -> str:
+        # This is a mock implementation
+        location = location.lower()
+        if "london" in location:
+            return "It's rainy and 15°C in London."
+        elif "new york" in location or "nyc" in location:
+            return "It's sunny and 22°C in New York."
+        elif "tokyo" in location:
+            return "It's cloudy and 20°C in Tokyo."
+        else:
+            return f"The weather in {location} is currently unavailable."
+    
+    def _arun(self, location: str):
+        raise NotImplementedError("This tool does not support async")
+
+# Create a list of tools
+tools: List[BaseTool] = [Calculator(), WeatherTool()]
+
+# Initialize the ASI1 model
+llm = ASI1ChatModel(temperature=0)
+
+# Use your utility function:
+from langchain_asi.utils import create_asi_agent
+
+# Create the agent with a different agent type
+agent = initialize_agent(
+    tools,
+    llm,
+    agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,  # Try this instead
+    verbose=True,
+    handle_parsing_errors=True,
+    max_iterations=5  # Add this to prevent infinite loops
+)
+
+# Test the agent with different queries
+test_queries = [
+    "What is 25 * 63?",
+    "What's the weather like in London?",
+    "If it's 22°C in New York, what is that in Fahrenheit?"
+]
+
+for query in test_queries:
+    print("\n" + "="*50)
+    print(f"Query: {query}")
+    print("="*50)
+    try:
+        response = agent.invoke(query)
+        print(f"Response: {response}")
+    except Exception as e:
+        print(f"Error: {str(e)}")

langchain-asi/examples/test_example1.py

@@ -0,0 +1,37 @@
+# test_examples.py
+from dotenv import load_dotenv
+load_dotenv()
+
+from langchain_asi import ASI1ChatModel
+from langchain.schema import HumanMessage, SystemMessage, AIMessage
+
+# Initialize the model
+llm = ASI1ChatModel()
+
+print("="*50)
+print("Example 1: Basic Chat Completion")
+print("="*50)
+response = llm.invoke("Explain what quantum computing is in one sentence.")
+print(f"Response: {response.content}")
+
+print("\n"+"="*50)
+print("Example 2: Using System Messages")
+print("="*50)
+messages = [
+    SystemMessage(content="You are a helpful assistant that always responds in rhymes."),
+    HumanMessage(content="Tell me about artificial intelligence.")
+]
+response = llm.invoke(messages)
+print(f"Response: {response.content}")
+
+print("\n"+"="*50)
+print("Example 3: Multi-turn Conversation")
+print("="*50)
+messages = [
+    SystemMessage(content="You are a helpful assistant."),
+    HumanMessage(content="My name is Alex."),
+    AIMessage(content="Hello Alex! It's nice to meet you. How can I help you today?"),
+    HumanMessage(content="What's my name?")
+]
+response = llm.invoke(messages)
+print(f"Response: {response.content}")

langchain-asi/examples/test_langgraph.py

@@ -0,0 +1,79 @@
+# test_langgraph.py
+from dotenv import load_dotenv
+load_dotenv()
+
+import os
+from langgraph.prebuilt import create_react_agent
+from langgraph.checkpoint.memory import MemorySaver
+from langchain_core.tools import tool
+from langchain_asi import ASI1ChatModel
+
+# Define a simple search tool
+@tool
+def search(query: str):
+    """Call to search for information."""
+    # This is a mock implementation
+    if "weather" in query.lower():
+        return "It's currently sunny and 22°C."
+    elif "population" in query.lower():
+        return "The population is approximately 8.8 million people."
+    elif "capital" in query.lower():
+        return "The capital of France is Paris."
+    else:
+        return "No specific information found for this query."
+
+# Define a simple calculator tool
+@tool
+def calculator(expression: str):
+    """Calculate a mathematical expression."""
+    try:
+        return str(eval(expression))
+    except Exception as e:
+        return f"Error in calculation: {str(e)}"
+
+# List of tools
+tools = [search, calculator]
+
+# Initialize the ASI1 model
+model = ASI1ChatModel(
+    model_name="asi1-mini",
+    temperature=0,  # Lower temperature for more deterministic responses
+    max_tokens=4000
+)
+
+# Initialize memory to persist state between graph runs
+checkpointer = MemorySaver()
+
+# Create the agent
+print("Creating LangGraph ReAct agent with ASI1...")
+app = create_react_agent(model, tools, checkpointer=checkpointer)
+
+# Test queries
+test_queries = [
+    "What is the capital of France?",
+    "What is 42 * 18?",
+    "What's the weather like today?"
+]
+
+# Run the tests
+for i, query in enumerate(test_queries):
+    print(f"\n{'='*50}")
+    print(f"Test {i+1}: {query}")
+    print(f"{'='*50}")
+    
+    try:
+        # Create a unique thread ID for each conversation
+        thread_id = f"test-thread-{i}"
+        
+        # Invoke the agent
+        final_state = app.invoke(
+            {"messages": [{"role": "user", "content": query}]},
+            config={"configurable": {"thread_id": thread_id}}
+        )
+        
+        # Print the final response
+        print("\nFinal Response:")
+        print(final_state["messages"][-1].content)
+        
+    except Exception as e:
+        print(f"Error: {str(e)}")

langchain-asi/examples/test_langgraph_weather.py

@@ -0,0 +1,38 @@
+#In place of anthropic, ASI model can be used
+from dotenv import load_dotenv
+load_dotenv()  # Load environment variables from .env file
+
+from langgraph.prebuilt import create_react_agent
+from langgraph.checkpoint.memory import MemorySaver
+from langchain_asi import ASI1ChatModel  # Your custom ASI1 integration
+from langchain_core.tools import tool
+
+# Define the tools for the agent to use
+@tool
+def search(query: str):
+    """Call to surf the web."""
+    # This is a placeholder implementation
+    if "sf" in query.lower() or "san francisco" in query.lower():
+        return "It's 60 degrees and foggy."
+    return "It's 90 degrees and sunny."
+
+# Create the list of tools
+tools = [search]
+
+# Initialize the ASI1 model
+model = ASI1ChatModel(model_name="asi1-mini", temperature=0)
+
+# Initialize memory to persist state between graph runs
+checkpointer = MemorySaver()
+
+# Create the ReAct agent
+app = create_react_agent(model, tools, checkpointer=checkpointer)
+
+# Use the agent to answer a weather question
+final_state = app.invoke(
+    {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+    config={"configurable": {"thread_id": 42}}
+)
+
+# Print the final response
+print(final_state["messages"][-1].content)

langchain-asi/import_test.py

@@ -0,0 +1,8 @@
+# import_test.py
+try:
+    import langchain_asi
+    print(f"Successfully imported langchain_asi from {langchain_asi.__file__}")
+    from langchain_asi import ASI1ChatModel
+    print("Successfully imported ASI1ChatModel")
+except ImportError as e:
+    print(f"Import error: {e}")

langchain-asi/langchain_asi.egg-info/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: langchain-asi
+Version: 0.1.0
+Summary: LangChain integration for ASI1 API
+Author: Rajashekar Vennavelli
+Author-email: rajashekarvennavelli@gmail.com
+Classifier: Development Status :: 3 - Alpha
+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
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: langchain>=0.0.267
+Requires-Dist: requests>=2.28.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

langchain-asi/langchain_asi.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+setup.py
+langchain_asi/__init__.py
+langchain_asi/chat_models.py
+langchain_asi/utils.py
+langchain_asi.egg-info/PKG-INFO
+langchain_asi.egg-info/SOURCES.txt
+langchain_asi.egg-info/dependency_links.txt
+langchain_asi.egg-info/requires.txt
+langchain_asi.egg-info/top_level.txt
+tests/test_agent.py
+tests/test_chat_model.py
+tests/test_integration.py
+tests/test_simple.py

langchain-asi/langchain_asi.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

langchain-asi/langchain_asi.egg-info/requires.txt

@@ -0,0 +1,2 @@
+langchain>=0.0.267
+requests>=2.28.0

langchain-asi/langchain_asi.egg-info/top_level.txt

@@ -0,0 +1 @@
+langchain_asi

langchain-asi/langchain_asi/__init__.py

@@ -0,0 +1,4 @@
+from langchain_asi.chat_models import ASI1ChatModel
+from langchain_asi.utils import create_asi_agent 
+
+__all__ = ["ASI1ChatModel", "create_asi_agent"]  

langchain-asi/langchain_asi/chat_models.py

@@ -0,0 +1,113 @@
+from langchain.chat_models.base import BaseChatModel
+from langchain.schema import AIMessage, HumanMessage, SystemMessage
+from langchain_core.outputs import ChatGeneration, ChatResult
+import requests
+import os
+from typing import List, Dict, Any, Optional, Union, Tuple
+
+class ASI1ChatModel(BaseChatModel):
+    """LangChain integration for ASI1 API chat models."""
+    
+    model_name: str = "asi1-mini"
+    temperature: float = 0.7
+    max_tokens: int = 4000
+    api_key: Optional[str] = None
+    api_base: str = "https://api.asi1.ai/v1"
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        # Get API key from environment or constructor
+        self.api_key = kwargs.get("api_key", os.environ.get("ASI1_API_KEY"))
+        if not self.api_key:
+            raise ValueError("ASI1_API_KEY must be provided as an argument or environment variable")
+        
+        # Override default params if provided
+        for param in ["model_name", "temperature", "max_tokens", "api_base"]:
+            if param in kwargs:
+                setattr(self, param, kwargs[param])
+    
+    def _generate(self, messages: List, stop: Optional[List[str]] = None, 
+                 **kwargs) -> ChatResult:
+        """Generate a completion using the ASI1 API."""
+        
+        # Convert LangChain message format to ASI1 format
+        asi_messages = []
+        for message in messages:
+            if isinstance(message, SystemMessage):
+                asi_messages.append({"role": "system", "content": message.content})
+            elif isinstance(message, HumanMessage):
+                asi_messages.append({"role": "user", "content": message.content})
+            elif isinstance(message, AIMessage):
+                asi_messages.append({"role": "assistant", "content": message.content})
+            elif hasattr(message, "content"):
+                # If it's a string, treat it as a user message
+                asi_messages.append({"role": "user", "content": str(message.content)})
+            else:
+                # If it's a string, treat it as a user message
+                asi_messages.append({"role": "user", "content": str(message)})
+        
+        # Prepare the request payload
+        payload = {
+            "model": self.model_name,
+            "messages": asi_messages,
+            "temperature": self.temperature,
+            "max_tokens": self.max_tokens
+        }
+        
+        # Add stop sequences if provided
+        if stop:
+            payload["stop"] = stop
+        
+        # Make the API request
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}"
+        }
+        
+        response = requests.post(
+            f"{self.api_base}/chat/completions",
+            headers=headers,
+            json=payload
+        )
+        
+        # Parse the response
+        if response.status_code != 200:
+            raise Exception(f"API request failed: {response.text}")
+        
+        result = response.json()
+        content = result["choices"][0]["message"]["content"]
+        
+        # Create an AIMessage
+        message = AIMessage(content=content)
+        
+        # Create a ChatGeneration with the message
+        generation = ChatGeneration(message=message)
+        
+        # Create and return a ChatResult
+        chat_result = ChatResult(generations=[generation])
+        
+        # Add token usage if available
+        if "usage" in result:
+            chat_result.llm_output = {
+                "token_usage": result["usage"],
+                "model_name": self.model_name
+            }
+        
+        return chat_result
+    
+    def _llm_type(self) -> str:
+        """Return type of LLM."""
+        return "asi1"
+    
+    def bind_tools(self, tools):
+        """Bind tools to the model.
+        
+        Args:
+            tools: List of tools to bind to the model
+            
+        Returns:
+            A new instance of the model with the tools bound
+        """
+    # For models that don't natively support tool binding,
+    # we just return the model itself
+        return self

langchain-asi/langchain_asi/utils.py

@@ -0,0 +1,43 @@
+from langchain.agents import initialize_agent, AgentType
+from langchain.tools.base import BaseTool
+from typing import List, Optional
+from langchain_asi.chat_models import ASI1ChatModel
+
+def create_asi_agent(tools: List[BaseTool], 
+                    system_prompt: Optional[str] = None,
+                    model_name: str = "asi1-mini",
+                    temperature: float = 0.7,
+                    max_tokens: int = 4000,
+                    api_key: Optional[str] = None,
+                    api_base: Optional[str] = None,
+                    agent_type: AgentType = AgentType.OPENAI_FUNCTIONS,
+                    handle_parsing_errors: bool = True):
+    """Create a LangChain agent using ASI1."""
+    
+    # Create ASI1 model
+    llm_kwargs = {
+        "model_name": model_name,
+        "temperature": temperature,
+        "max_tokens": max_tokens
+    }
+    if api_key:
+        llm_kwargs["api_key"] = api_key
+    if api_base:
+        llm_kwargs["api_base"] = api_base
+        
+    llm = ASI1ChatModel(**llm_kwargs)
+    
+    # Create and return agent
+    if system_prompt:
+        agent_kwargs = {"system_message": system_prompt}
+    else:
+        agent_kwargs = {}
+        
+    return initialize_agent(
+        tools=tools,
+        llm=llm,
+        agent=agent_type,
+        agent_kwargs=agent_kwargs,
+        verbose=True,
+        handle_parsing_errors=handle_parsing_errors
+    )

langchain-asi/requirements.txt

@@ -0,0 +1,18 @@
+# Core dependencies
+langchain>=0.0.267
+requests>=2.28.0
+
+# Testing
+pytest>=7.0.0
+python-dotenv>=1.0.0
+
+# Development
+black>=23.0.0
+isort>=5.12.0
+mypy>=1.0.0
+build>=0.10.0
+twine>=4.0.0
+
+# Example dependencies
+langgraph>=0.0.15
+langgraph-prebuilt>=0.0.5

langchain-asi/setup.py

@@ -0,0 +1,25 @@
+# setup.py
+from setuptools import setup, find_packages
+
+setup(
+    name="langchain-asi",
+    version="0.1.0",
+    description="LangChain integration for ASI1 API",
+    author="Rajashekar Vennavelli",
+    author_email="rajashekarvennavelli@gmail.com",
+    packages=find_packages(),
+    install_requires=[
+        "langchain>=0.0.267",
+        "requests>=2.28.0"
+    ],
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "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",
+    ],
+    python_requires=">=3.8",
+)

langchain-asi/tests/conftest.py

@@ -0,0 +1,16 @@
+# tests/conftest.py
+import os
+import pytest
+from dotenv import load_dotenv
+
+# tests/conftest.py
+import sys
+import os
+from pathlib import Path
+
+# Add the project root directory to sys.path
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))
+
+print(f"Added {project_root} to sys.path")
+print(f"sys.path is now: {sys.path}")

langchain-asi/tests/test_agent.py

@@ -0,0 +1,56 @@
+# tests/test_agent.py
+import os
+import pytest
+from langchain_asi import ASI1ChatModel
+from langchain_asi.utils import create_asi_agent
+from langchain.tools import BaseTool
+
+# Skip tests if no API key is available
+requires_api_key = pytest.mark.skipif(
+    not os.environ.get("ASI1_API_KEY"),
+    reason="ASI1_API_KEY environment variable not set"
+)
+
+class TestAgentIntegration:
+    
+    def setup_method(self):
+        """Set up the test fixture."""
+        self.model = ASI1ChatModel()
+        
+        # Define a simple calculator tool
+        class Calculator(BaseTool):
+            name: str = "calculator"
+            description: str = "Useful for math calculations"
+            
+            def _run(self, query: str) -> str:
+                try:
+                    return str(eval(query))
+                except Exception as e:
+                    return f"Error: {str(e)}"
+            
+            def _arun(self, query: str):
+                raise NotImplementedError("Async not supported")
+        
+        self.tools = [Calculator()]
+    
+    @requires_api_key
+    def test_create_agent(self):
+        """Test creating an agent with tools."""
+        agent = create_asi_agent(
+            tools=self.tools,
+            system_prompt="You are a helpful assistant."
+        )
+        assert agent is not None
+    
+    @requires_api_key
+    def test_agent_calculation(self):
+        """Test that the agent can use tools to solve problems."""
+        agent = create_asi_agent(
+            tools=self.tools,
+            system_prompt="You are a helpful assistant.",
+            handle_parsing_errors=True
+        )
+        response = agent.invoke("What is 25 * 42?")
+        
+        # Check if '1050' is in the output field of the response
+        assert "1050" in response['output']

langchain-asi/tests/test_chat_model.py

@@ -0,0 +1,63 @@
+# tests/test_chat_model.py
+import os
+import pytest
+from langchain_asi import ASI1ChatModel
+from langchain.schema import HumanMessage, SystemMessage, AIMessage
+
+# Skip tests if no API key is available
+requires_api_key = pytest.mark.skipif(
+    not os.environ.get("ASI1_API_KEY"),
+    reason="ASI1_API_KEY environment variable not set"
+)
+
+class TestASI1ChatModel:
+    
+    def setup_method(self):
+        """Set up the test fixture."""
+        self.model = ASI1ChatModel()
+    
+    @requires_api_key
+    def test_initialization(self):
+        """Test model initialization with different parameters."""
+        # Default initialization
+        model1 = ASI1ChatModel()
+        assert model1.model_name == "asi1-mini"
+        assert model1.temperature == 0.7
+        
+        # Custom parameters
+        model2 = ASI1ChatModel(model_name="custom-model", temperature=0.3)
+        assert model2.model_name == "custom-model"
+        assert model2.temperature == 0.3
+    
+    @requires_api_key
+    def test_invoke_with_string(self):
+        """Test model invocation with a string."""
+        response = self.model.invoke("Hello, how are you?")
+        assert isinstance(response, AIMessage)
+        assert len(response.content) > 0
+    
+    @requires_api_key
+    def test_invoke_with_messages(self):
+        """Test model invocation with a list of messages."""
+        messages = [
+            SystemMessage(content="You are a helpful assistant."),
+            HumanMessage(content="What is the capital of France?")
+        ]
+        response = self.model.invoke(messages)
+        assert isinstance(response, AIMessage)
+        assert len(response.content) > 0
+        assert "Paris" in response.content
+    
+    @requires_api_key
+    def test_bind_tools(self):
+        """Test binding tools to the model."""
+        from langchain.tools import tool
+        
+        @tool
+        def calculator(expression: str) -> str:
+            """Calculate a mathematical expression."""
+            return str(eval(expression))
+        
+        tools = [calculator]
+        model_with_tools = self.model.bind_tools(tools)
+        assert model_with_tools is not None

langchain-asi/tests/test_integration.py

@@ -0,0 +1,30 @@
+# tests/test_integration.py
+import os
+import pytest
+from langchain_asi import ASI1ChatModel
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+
+# Skip tests if no API key is available
+requires_api_key = pytest.mark.skipif(
+    not os.environ.get("ASI1_API_KEY"),
+    reason="ASI1_API_KEY environment variable not set"
+)
+
+class TestLangChainIntegration:
+    
+    def setup_method(self):
+        """Set up the test fixture."""
+        self.model = ASI1ChatModel()
+    
+    @requires_api_key
+    def test_llm_chain(self):
+        """Test using the model in a LLMChain."""
+        prompt = PromptTemplate(
+            input_variables=["topic"],
+            template="Write a one-sentence summary about {topic}."
+        )
+        chain = LLMChain(llm=self.model, prompt=prompt)
+        result = chain.run("quantum computing")
+        assert len(result) > 0
+        assert isinstance(result, str)

langchain-asi/tests/test_simple.py

@@ -0,0 +1,5 @@
+# tests/test_simple.py
+def test_import():
+    """Test that langchain_asi can be imported."""
+    import langchain_asi
+    assert hasattr(langchain_asi, "ASI1ChatModel")