axcent 0.1.0__tar.gz

axcent-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mohin Uddin Shipon
+
+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.

axcent-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include LICENSE

axcent-0.1.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: axcent
+Version: 0.1.0
+Summary: The easiest way to build AI agents in Python
+Home-page: https://github.com/ssshiponu/axcent
+Author: Mohin Uddin Shipon
+Author-email: sshiponudin22@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=1.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: gemini
+Requires-Dist: google-genai>=1.57.0; extra == "gemini"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Axcent
+
+**The easiest way to build AI agents in Python.**
+
+Axcent is a lightweight framework designed to let you build powerful AI agents with tool calling, context caching, and multi-backend support in just a few lines of code.
+
+## Installation
+
+```bash
+pip install axcent
+```
+
+To use Gemini models:
+```bash
+pip install axcent[gemini]
+```
+
+## Quick Start (OpenAI)
+
+```python
+import os
+from axcent import Agent
+
+# Set your API Key
+os.environ["OPENAI_API_KEY"] = "sk-..."
+
+# Initialize Agent
+agent = Agent(system_prompt="You are a helpful assistant.")
+
+# Register a Tool
+@agent.tool
+def get_weather(city: str) -> str:
+    """Returns weather info for a city."""
+    return f"The weather in {city} is sunny!"
+
+# Ask away!
+response = agent.ask("What is the weather in Tokyo?")
+print(response)
+```
+
+## Features
+
+- **Simple Tool Registration**: Just use `@agent.tool`.
+- **Automatic Context Caching**: Optimizes token usage by enforcing stable prompt structures.
+- **Token Monitoring**: Track prompt, completion, and cached tokens via `agent.get_total_usage()`.
+- **Backend Agnostic**:
+    - **OpenAI**: First-class support.
+    - **Google Gemini**: Support for all of the latest models.
+    - **OpenRouter**: Use any model via OpenRouter API compatibility.
+
+## Multi-Backend Usage
+
+### Google Gemini
+
+```python
+from axcent import Agent, GeminiBackend
+import os
+
+# Set API Key (or GOOGLE_API_KEY)
+os.environ["GEMINI_API_KEY"] = "AIza..."
+
+# Use Gemini Backend (uses google-genai V2 SDK)
+backend = GeminiBackend(model="gemini-3-flash")
+agent = Agent(system_prompt="You are a helper.", backend=backend)
+```
+
+### OpenRouter
+
+```python
+import os
+from axcent import Agent
+
+os.environ["OPENAI_API_KEY"] = "sk-or-..."
+os.environ["OPENAI_BASE_URL"] = "https://openrouter.ai/api/v1"
+
+agent = Agent(system_prompt="You are a helper.")
+```
+
+## License
+
+MIT

axcent-0.1.0/README.md

@@ -0,0 +1,81 @@
+# Axcent
+
+**The easiest way to build AI agents in Python.**
+
+Axcent is a lightweight framework designed to let you build powerful AI agents with tool calling, context caching, and multi-backend support in just a few lines of code.
+
+## Installation
+
+```bash
+pip install axcent
+```
+
+To use Gemini models:
+```bash
+pip install axcent[gemini]
+```
+
+## Quick Start (OpenAI)
+
+```python
+import os
+from axcent import Agent
+
+# Set your API Key
+os.environ["OPENAI_API_KEY"] = "sk-..."
+
+# Initialize Agent
+agent = Agent(system_prompt="You are a helpful assistant.")
+
+# Register a Tool
+@agent.tool
+def get_weather(city: str) -> str:
+    """Returns weather info for a city."""
+    return f"The weather in {city} is sunny!"
+
+# Ask away!
+response = agent.ask("What is the weather in Tokyo?")
+print(response)
+```
+
+## Features
+
+- **Simple Tool Registration**: Just use `@agent.tool`.
+- **Automatic Context Caching**: Optimizes token usage by enforcing stable prompt structures.
+- **Token Monitoring**: Track prompt, completion, and cached tokens via `agent.get_total_usage()`.
+- **Backend Agnostic**:
+    - **OpenAI**: First-class support.
+    - **Google Gemini**: Support for all of the latest models.
+    - **OpenRouter**: Use any model via OpenRouter API compatibility.
+
+## Multi-Backend Usage
+
+### Google Gemini
+
+```python
+from axcent import Agent, GeminiBackend
+import os
+
+# Set API Key (or GOOGLE_API_KEY)
+os.environ["GEMINI_API_KEY"] = "AIza..."
+
+# Use Gemini Backend (uses google-genai V2 SDK)
+backend = GeminiBackend(model="gemini-3-flash")
+agent = Agent(system_prompt="You are a helper.", backend=backend)
+```
+
+### OpenRouter
+
+```python
+import os
+from axcent import Agent
+
+os.environ["OPENAI_API_KEY"] = "sk-or-..."
+os.environ["OPENAI_BASE_URL"] = "https://openrouter.ai/api/v1"
+
+agent = Agent(system_prompt="You are a helper.")
+```
+
+## License
+
+MIT

axcent-0.1.0/axcent/__init__.py

@@ -0,0 +1,2 @@
+from .core import Agent
+from .llm import OpenAIBackend, GeminiBackend, MockBackend

axcent-0.1.0/axcent/core.py

@@ -0,0 +1,93 @@
+import json
+from typing import Callable, Dict, List, Any, Optional
+from .tools import function_to_schema
+from .llm import LLMBackend, OpenAIBackend
+
+class Agent:
+    def __init__(self, system_prompt: str = "You are a helpful assistant.", backend: LLMBackend = None, model: str = "gpt-4o-mini"):
+        self.system_prompt = system_prompt
+        self.backend = backend or OpenAIBackend(model=model)
+        self.history: List[Dict[str, Any]] = [{"role": "system", "content": system_prompt}]
+        self.tools: Dict[str, Callable] = {}
+        self.tool_schemas: List[Dict[str, Any]] = []
+        self.usage_history: List[Dict[str, int]] = []
+
+    def get_total_usage(self) -> Dict[str, int]:
+        """Returns the total token usage across all requests."""
+        total = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0, "cached_tokens": 0}
+        for usage in self.usage_history:
+            total["prompt_tokens"] += usage.get("prompt_tokens", 0)
+            total["completion_tokens"] += usage.get("completion_tokens", 0)
+            total["total_tokens"] += usage.get("total_tokens", 0)
+            total["cached_tokens"] += usage.get("cached_tokens", 0)
+        return total
+
+    def tool(self, func: Callable):
+        """Decorator to register a tool."""
+        schema = function_to_schema(func)
+        self.tools[func.__name__] = func
+        self.tool_schemas.append(schema)
+        return func
+
+    def ask(self, query: str) -> str:
+        """
+        Sends a query to the agent and returns the response.
+        Handles tool calls automatically.
+        """
+        self.history.append({"role": "user", "content": query})
+        
+        while True:
+            # Sort tools by name to ensure consistent order for OpenAI prompt caching
+            current_tools = sorted(self.tool_schemas, key=lambda x: x['function']['name']) if self.tool_schemas else None
+            response = self.backend.chat(self.history, tools=current_tools)
+            message = response.choices[0].message
+            
+            # Track Usage
+            if hasattr(response, 'usage') and response.usage:
+                usage_data = {
+                    "prompt_tokens": response.usage.prompt_tokens,
+                    "completion_tokens": response.usage.completion_tokens,
+                    "total_tokens": response.usage.total_tokens,
+                    "cached_tokens": 0
+                }
+                # Check for cached tokens (OpenAI specific structure)
+                if hasattr(response.usage, 'prompt_tokens_details') and response.usage.prompt_tokens_details:
+                     if hasattr(response.usage.prompt_tokens_details, 'cached_tokens'):
+                         usage_data["cached_tokens"] = response.usage.prompt_tokens_details.cached_tokens
+                
+                self.usage_history.append(usage_data)
+            
+            # Convert message to dict to ensure compatibility with next API call
+            message_dict = {
+                "role": message.role,
+                "content": message.content,
+            }
+            if message.tool_calls:
+                 message_dict["tool_calls"] = message.tool_calls
+            
+            self.history.append(message_dict)
+
+            if hasattr(message, 'tool_calls') and message.tool_calls:
+                for tool_call in message.tool_calls:
+                    function_name = tool_call.function.name
+                    arguments = json.loads(tool_call.function.arguments)
+                    
+                    if function_name in self.tools:
+                        func = self.tools[function_name]
+                        try:
+                            result = func(**arguments)
+                            content = str(result)
+                        except Exception as e:
+                            content = f"Error executing tool: {e}"
+                    else:
+                        content = f"Error: Tool {function_name} not found."
+                        
+                    self.history.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "content": content
+                    })
+                # Continue loop to let LLM process tool outputs
+            else:
+                # No tool calls, return content
+                return message.content

axcent-0.1.0/axcent/llm.py

@@ -0,0 +1,215 @@
+import os
+import json
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Optional
+
+class LLMBackend(ABC):
+    @abstractmethod
+    def chat(self, messages: List[Dict[str, Any]], tools: Optional[List[Dict[str, Any]]] = None) -> Any:
+        pass
+
+class OpenAIBackend(LLMBackend):
+    def __init__(self, api_key: str = None, model: str = "gpt-4o-mini", base_url: str = None):
+        import openai
+        self.client = openai.OpenAI(
+            api_key=api_key or os.environ.get("OPENAI_API_KEY"),
+            base_url=base_url or os.environ.get("OPENAI_BASE_URL")
+        )
+        self.model = model
+
+    def chat(self, messages: List[Dict[str, Any]], tools: Optional[List[Dict[str, Any]]] = None) -> Any:
+        # Filter out tool_map form tool definition if present (not needed for API)
+        # But here 'tools' is expected to be the list of schemas.
+        
+        kwargs = {
+            "model": self.model,
+            "messages": messages,
+        }
+        if tools:
+            kwargs["tools"] = tools
+            kwargs["tool_choice"] = "auto"
+            
+        return self.client.chat.completions.create(**kwargs)
+
+class MockBackend(LLMBackend):
+    def __init__(self, responses: List[str] = None):
+        self.responses = responses or ["I am a mock agent."]
+        self.calls = []
+
+    def chat(self, messages: List[Dict[str, Any]], tools: Optional[List[Dict[str, Any]]] = None) -> Any:
+        self.calls.append({"messages": messages, "tools": tools})
+        
+        # Simple mock response object mimicking OpenAI's structure
+        class MockChoice:
+            def __init__(self, content):
+                self.message = type('obj', (object,), {'content': content, 'tool_calls': None})
+
+        class MockResponse:
+            def __init__(self, content):
+                self.choices = [MockChoice(content)]
+        
+        return MockResponse(self.responses.pop(0) if self.responses else "No more mock responses.")
+
+class GeminiBackend(LLMBackend):
+    def __init__(self, api_key: str = None, model: str = "gemini-2.5-flash"):
+        from google import genai
+        self.client = genai.Client(api_key=api_key or os.environ.get("GEMINI_API_KEY"))
+        if not self.client.api_key:
+             # The new SDK might pick it up from env automatically, but let's be safe
+             if not os.environ.get("GEMINI_API_KEY") and not os.environ.get("GOOGLE_API_KEY"):
+                  raise ValueError("GEMINI_API_KEY or GOOGLE_API_KEY not found.")
+        self.model_name = model
+
+    def _convert_tools(self, tools: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Converts OpenAI tool schemas to Gemini V2 tool definitions."""
+        if not tools:
+            return None
+        
+        # The new SDK supports providing a list of tool configurations.
+        # It can accept raw function callables, or a Tool object.
+        # For manual schema control, we define it as a list of 'function_declarations'.
+        
+        from google.genai import types
+        
+        function_declarations = []
+        for tool in tools:
+            fn = tool['function']
+            # google-genai uses a simplified schema definition or standard OpenAPI-like dicts.
+            # We can use the text-based definition or constructs.
+            # Let's use the dict structure which is close to OpenAI's but structured under 'function_declarations'.
+            
+            function_declarations.append({
+                "name": fn['name'],
+                "description": fn.get('description'),
+                "parameters": fn.get('parameters')
+            })
+            
+        # The API expects: tools=[{'function_declarations': [...]}]
+        return [{"function_declarations": function_declarations}]
+
+    def chat(self, messages: List[Dict[str, Any]], tools: Optional[List[Dict[str, Any]]] = None) -> Any:
+        gemini_tools = self._convert_tools(tools)
+        
+        # Convert History
+        # The new SDK uses 'contents' with 'role' (user/model) and 'parts'.
+        # 'system' instructions are passed separately to generate_content config.
+        
+        contents = []
+        system_instruction = None
+        
+        for msg in messages:
+            role = msg['role']
+            content = msg.get('content')
+            
+            if role == "system":
+                system_instruction = content
+            elif role == "user":
+                contents.append({"role": "user", "parts": [{"text": content}]})
+            elif role == "assistant":
+                parts = []
+                if content:
+                    parts.append({"text": content})
+                if "tool_calls" in msg:
+                    for tc in msg["tool_calls"]:
+                        parts.append({
+                            "function_call": {
+                                "name": tc.function.name,
+                                "args": json.loads(tc.function.arguments)
+                            }
+                        })
+                contents.append({"role": "model", "parts": parts})
+            elif role == "tool":
+                # Find valid previous call or just append. 
+                # The V2 SDK expects 'role': 'tool' (or 'function' depending on precise version parity).
+                # Actually, standard Vertex/Gemini API V1beta uses 'function_response' inside 'function' role.
+                # V2 SDK `types.Content` also supports role='tool'.
+                
+                # We need to match the function name.
+                # Since we are iterating strictly, we can try to look up key by tool_call_id if we had a map.
+                # Re-scanning messages for map:
+                tool_map = {}
+                for m in messages:
+                    if m['role'] == 'assistant' and 'tool_calls' in m:
+                        for tc in m['tool_calls']:
+                            tool_map[tc.id] = tc.function.name
+                
+                fname = tool_map.get(msg.get('tool_call_id'), 'unknown')
+                
+                contents.append({
+                    "role": "user", # In many google apis, function response is user-side.
+                    # HOWEVER, verify SDK V2. 
+                    # Docs say: function responses are part of the conversation.
+                    # Let's try 'user' role with 'function_response' part.
+                    "parts": [{
+                        "function_response": {
+                            "name": fname,
+                            "response": {"result": content}
+                        }
+                    }]
+                })
+
+        from google.genai import types
+        
+        config = types.GenerateContentConfig(
+            system_instruction=system_instruction,
+            tools=gemini_tools,
+            temperature=0.7, # Default setup
+        )
+
+        response = self.client.models.generate_content(
+            model=self.model_name,
+            contents=contents,
+            config=config
+        )
+
+        # Map response back to OpenAI format
+        class OpenAICompatMessage:
+            def __init__(self, content, tool_calls=None, role="assistant"):
+                self.content = content
+                self.tool_calls = tool_calls
+                self.role = role
+
+        class OpenAICompatChoice:
+            def __init__(self, message):
+                self.message = message
+
+        class OpenAICompatResponse:
+            def __init__(self, choices, usage=None):
+                self.choices = choices
+                self.usage = usage
+
+        content_text = None
+        tool_calls = []
+
+        # Parse candidates
+        if response.candidates and response.candidates[0].content.parts:
+            for part in response.candidates[0].content.parts:
+                if part.text:
+                    content_text = (content_text or "") + part.text
+                if part.function_call:
+                    tool_calls.append(type('obj', (object,), {
+                        'id': 'call_' + part.function_call.name, 
+                        'function': type('obj', (object,), {
+                            'name': part.function_call.name,
+                            'arguments': json.dumps(part.function_call.args)
+                        })
+                    }))
+
+        # Usage
+        usage = None
+        if response.usage_metadata:
+             usage = type('obj', (object,), {
+                'prompt_tokens': response.usage_metadata.prompt_token_count,
+                'completion_tokens': response.usage_metadata.candidates_token_count,
+                'total_tokens': response.usage_metadata.total_token_count,
+                 # Check if cached content is exposed in usage_metadata in V2
+                 # It's usually present if implicit caching happened.
+                'prompt_tokens_details': type('obj', (object,), {
+                    'cached_tokens': getattr(response.usage_metadata, 'cached_content_token_count', 0)
+                })
+            })
+
+        return OpenAICompatResponse(
+            choices=[OpenAICompatChoice(OpenAICompatMessage(content_text, tool_calls if tool_calls else None))],
+            usage=usage
+        )

axcent-0.1.0/axcent/tools.py

@@ -0,0 +1,56 @@
+import inspect
+import typing
+
+def type_to_json_type(t: typing.Any) -> str:
+    """Maps Python types to JSON Safe types."""
+    if t == str:
+        return "string"
+    elif t == int:
+        return "integer"
+    elif t == float:
+        return "number"
+    elif t == bool:
+        return "boolean"
+    elif t == list or typing.get_origin(t) == list:
+        return "array"
+    elif t == dict or typing.get_origin(t) == dict:
+        return "object"
+    else:
+        return "string"  # Default fallback
+
+def function_to_schema(func: typing.Callable) -> dict:
+    """
+    Converts a Python function into an OpenAI tool schema.
+    Uses type hints and docstrings.
+    """
+    sig = inspect.signature(func)
+    doc = inspect.getdoc(func) or "No description provided."
+    name = func.__name__
+
+    parameters = {
+        "type": "object",
+        "properties": {},
+        "required": [],
+    }
+
+    for param_name, param in sig.parameters.items():
+        if param_name == "self":
+            continue
+        
+        param_type = type_to_json_type(param.annotation) if param.annotation != inspect.Parameter.empty else "string"
+        
+        parameters["properties"][param_name] = {
+            "type": param_type
+        }
+        
+        if param.default == inspect.Parameter.empty:
+            parameters["required"].append(param_name)
+
+    return {
+        "type": "function",
+        "function": {
+            "name": name,
+            "description": doc,
+            "parameters": parameters,
+        }
+    }

axcent-0.1.0/axcent.egg-info/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: axcent
+Version: 0.1.0
+Summary: The easiest way to build AI agents in Python
+Home-page: https://github.com/ssshiponu/axcent
+Author: Mohin Uddin Shipon
+Author-email: sshiponudin22@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=1.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: gemini
+Requires-Dist: google-genai>=1.57.0; extra == "gemini"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Axcent
+
+**The easiest way to build AI agents in Python.**
+
+Axcent is a lightweight framework designed to let you build powerful AI agents with tool calling, context caching, and multi-backend support in just a few lines of code.
+
+## Installation
+
+```bash
+pip install axcent
+```
+
+To use Gemini models:
+```bash
+pip install axcent[gemini]
+```
+
+## Quick Start (OpenAI)
+
+```python
+import os
+from axcent import Agent
+
+# Set your API Key
+os.environ["OPENAI_API_KEY"] = "sk-..."
+
+# Initialize Agent
+agent = Agent(system_prompt="You are a helpful assistant.")
+
+# Register a Tool
+@agent.tool
+def get_weather(city: str) -> str:
+    """Returns weather info for a city."""
+    return f"The weather in {city} is sunny!"
+
+# Ask away!
+response = agent.ask("What is the weather in Tokyo?")
+print(response)
+```
+
+## Features
+
+- **Simple Tool Registration**: Just use `@agent.tool`.
+- **Automatic Context Caching**: Optimizes token usage by enforcing stable prompt structures.
+- **Token Monitoring**: Track prompt, completion, and cached tokens via `agent.get_total_usage()`.
+- **Backend Agnostic**:
+    - **OpenAI**: First-class support.
+    - **Google Gemini**: Support for all of the latest models.
+    - **OpenRouter**: Use any model via OpenRouter API compatibility.
+
+## Multi-Backend Usage
+
+### Google Gemini
+
+```python
+from axcent import Agent, GeminiBackend
+import os
+
+# Set API Key (or GOOGLE_API_KEY)
+os.environ["GEMINI_API_KEY"] = "AIza..."
+
+# Use Gemini Backend (uses google-genai V2 SDK)
+backend = GeminiBackend(model="gemini-3-flash")
+agent = Agent(system_prompt="You are a helper.", backend=backend)
+```
+
+### OpenRouter
+
+```python
+import os
+from axcent import Agent
+
+os.environ["OPENAI_API_KEY"] = "sk-or-..."
+os.environ["OPENAI_BASE_URL"] = "https://openrouter.ai/api/v1"
+
+agent = Agent(system_prompt="You are a helper.")
+```
+
+## License
+
+MIT

axcent-0.1.0/axcent.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+axcent/__init__.py
+axcent/core.py
+axcent/llm.py
+axcent/tools.py
+axcent.egg-info/PKG-INFO
+axcent.egg-info/SOURCES.txt
+axcent.egg-info/dependency_links.txt
+axcent.egg-info/requires.txt
+axcent.egg-info/top_level.txt

axcent-0.1.0/axcent.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

axcent-0.1.0/axcent.egg-info/requires.txt

@@ -0,0 +1,5 @@
+openai>=1.0.0
+python-dotenv>=1.0.0
+
+[gemini]
+google-genai>=1.57.0

axcent-0.1.0/axcent.egg-info/top_level.txt

@@ -0,0 +1 @@
+axcent

axcent-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

axcent-0.1.0/setup.cfg

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

axcent-0.1.0/setup.py

@@ -0,0 +1,27 @@
+import os
+from setuptools import setup, find_packages
+
+setup(
+    name="axcent",
+    version="0.1.0",
+    description="The easiest way to build AI agents in Python",
+    long_description=open("README.md").read() if os.path.exists("README.md") else "",
+    long_description_content_type="text/markdown",
+    author="Mohin Uddin Shipon",
+    author_email="sshiponudin22@gmail.com",
+    url="https://github.com/ssshiponu/axcent",
+    packages=find_packages(),
+    install_requires=[
+        "openai>=1.0.0",
+        "python-dotenv>=1.0.0",
+    ],
+    extras_require={
+        "gemini": ["google-genai>=1.57.0"],
+    },
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires='>=3.8',
+)