nixagent 1.0__tar.gz

nixagent-1.0/LICENSE

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

nixagent-1.0/MANIFEST.in

@@ -0,0 +1,10 @@
+include README.md
+include LICENSE
+include requirements.txt
+include *.py
+recursive-include helper *.py
+recursive-include agents *.py
+global-exclude __pycache__
+global-exclude *.py[co]
+global-exclude .DS_Store
+prune __test__

nixagent-1.0/PKG-INFO

@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: nixagent
+Version: 1.0
+Summary: A sophisticated AI agent toolkit supporting multiple AI providers with tool calling capabilities.
+Home-page: https://technicalheist.com
+Author: TechnicalHeist
+Author-email: TechnicalHeist <contact@technicalheist.com>
+License: MIT
+Project-URL: Homepage, https://technicalheist.com
+Project-URL: Repository, https://github.com/technicalheist/local-agent-toolkit
+Project-URL: Issues, https://github.com/technicalheist/local-agent-toolkit/issues
+Keywords: ai,agent,toolkit,ollama,openai,tool-calling,automation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-dotenv>=0.19.0
+Requires-Dist: requests>=2.25.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.0; extra == "dev"
+Requires-Dist: black>=21.0; extra == "dev"
+Requires-Dist: flake8>=3.8; extra == "dev"
+Requires-Dist: build>=0.8.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Local Agent Toolkit
+
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A generic, multipurpose Local Agent Toolkit in Python. This framework is completely agnostic to specific use cases and architectures, serving as a robust foundation for building autonomous, collaborative AI agents that can manage their own context, interface with each other, and securely use external tools. 
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+### Command Line Usage
+
+First, set up your environment configuration by copying `.env.example` to `.env` and adding your API keys.
+
+```bash
+# Ask a question directly
+python app.py "What files are in the current directory?"
+
+# Interactive mode
+python app.py
+
+# With custom settings
+python app.py "Analyze the code structure" --no-save
+```
+
+### Python Library Usage
+
+```python
+from local_agent_toolkit import Agent
+
+# Initialize the core agent
+agent = Agent(
+    name="MainAgent",
+    system_prompt="You are a highly capable AI assistant that uses available tools to accomplish goals."
+)
+
+result = agent.run(user_prompt="List all Python files in the project")
+print(result)
+```
+
+## ✨ Features
+
+- **🌐 Standardized API Interface**: Uses pure `requests` following the OpenAI native JSON structure. Compatible with OpenAI, Vertex, Local LLMs (via Ollama/vLLM), Groq, and more.
+- **🤖 Autonomous Agents**: Agents maintain independent conversation histories and automatically delegate sub-tasks when needed.
+- **🔌 Model Context Protocol (MCP)**: Dynamic tool extension via MCP Servers via `.mcp.json`.
+- **🛠️ Rich Built-In Tools**: Deep system-level tools covering regex-based file searching, exact content mapping, disk manipulation, and secure subprocess execution.
+- **🗣️ Inter-Agent Collaboration**: Support for multiple sub-agents operating concurrently under the same framework via `.register_collaborator(agent)`.
+
+## 📦 Project Structure
+
+```text
+framework/
+├── app.py                # Main CLI application
+├── local_agent_toolkit/  # Core Framework Mechanics
+│   ├── __init__.py       # Library exports
+│   ├── agent.py          # Core contextual autonomous Agent
+│   ├── llm.py            # Central HTTP-based LLM orchestration
+│   ├── mcp.py            # Model Context Protocol definition and bindings
+│   └── tools/            # Default Native Tools
+│       ├── __init__.py   # Tool bindings & descriptions
+│       ├── cmd.py        # Subprocess shell extensions
+│       └── fs.py         # File system native operations
+├── mcp.json              # Model Context Protocol Server mapping
+├── docs/                 # Additional Documentation
+├── requirements.txt      # Python dependencies
+├── .env                  # Operational mapping variables
+└── README.md             # This file
+```
+
+## ⚙️ Configuration
+
+Create a `.env` file in your project root:
+
+```bash
+# Core API Key for the provider (OpenAI, Gemini, Vertex, Groq, etc)
+API_KEY=your_api_key_here
+
+# Base URL for the OpenAI compatible endpoint
+API_BASE_URL=https://api.openai.com/v1
+
+# The model name to use for generating text
+MODEL=gpt-4o
+
+# Tool and Processing Configuration
+MAX_ITERATIONS=25
+
+# Logging Configuration
+LOG_LEVEL=INFO
+```
+
+## 🔌 Using MCP Servers
+
+Add server definitions to your `mcp.json` file in the root directory:
+
+```json
+{
+  "mcpServers": {
+    "sqlite": {
+      "command": "uvx",
+      "args": ["mcp-server-sqlite", "--db-path", "./database.db"],
+      "active": true
+    }
+  }
+}
+```
+
+The framework's `MCPManager` automatically bootstraps all active MCP servers, parses their schemas, and loads their tools natively alongside standard tools upon Agent initialization.
+
+## 🤝 Collaborative Agents
+
+Agents can securely establish communication networks.
+
+```python
+from local_agent_toolkit import Agent
+
+research_agent = Agent("Researcher", "You perform file system research.")
+writer_agent = Agent("Writer", "You answer questions accurately.")
+
+writer_agent.register_collaborator(research_agent)
+
+writer_agent.run("Ask the Researcher to find all text files and read them to me.")
+```
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

nixagent-1.0/README.md

@@ -0,0 +1,131 @@
+# Local Agent Toolkit
+
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A generic, multipurpose Local Agent Toolkit in Python. This framework is completely agnostic to specific use cases and architectures, serving as a robust foundation for building autonomous, collaborative AI agents that can manage their own context, interface with each other, and securely use external tools. 
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+### Command Line Usage
+
+First, set up your environment configuration by copying `.env.example` to `.env` and adding your API keys.
+
+```bash
+# Ask a question directly
+python app.py "What files are in the current directory?"
+
+# Interactive mode
+python app.py
+
+# With custom settings
+python app.py "Analyze the code structure" --no-save
+```
+
+### Python Library Usage
+
+```python
+from local_agent_toolkit import Agent
+
+# Initialize the core agent
+agent = Agent(
+    name="MainAgent",
+    system_prompt="You are a highly capable AI assistant that uses available tools to accomplish goals."
+)
+
+result = agent.run(user_prompt="List all Python files in the project")
+print(result)
+```
+
+## ✨ Features
+
+- **🌐 Standardized API Interface**: Uses pure `requests` following the OpenAI native JSON structure. Compatible with OpenAI, Vertex, Local LLMs (via Ollama/vLLM), Groq, and more.
+- **🤖 Autonomous Agents**: Agents maintain independent conversation histories and automatically delegate sub-tasks when needed.
+- **🔌 Model Context Protocol (MCP)**: Dynamic tool extension via MCP Servers via `.mcp.json`.
+- **🛠️ Rich Built-In Tools**: Deep system-level tools covering regex-based file searching, exact content mapping, disk manipulation, and secure subprocess execution.
+- **🗣️ Inter-Agent Collaboration**: Support for multiple sub-agents operating concurrently under the same framework via `.register_collaborator(agent)`.
+
+## 📦 Project Structure
+
+```text
+framework/
+├── app.py                # Main CLI application
+├── local_agent_toolkit/  # Core Framework Mechanics
+│   ├── __init__.py       # Library exports
+│   ├── agent.py          # Core contextual autonomous Agent
+│   ├── llm.py            # Central HTTP-based LLM orchestration
+│   ├── mcp.py            # Model Context Protocol definition and bindings
+│   └── tools/            # Default Native Tools
+│       ├── __init__.py   # Tool bindings & descriptions
+│       ├── cmd.py        # Subprocess shell extensions
+│       └── fs.py         # File system native operations
+├── mcp.json              # Model Context Protocol Server mapping
+├── docs/                 # Additional Documentation
+├── requirements.txt      # Python dependencies
+├── .env                  # Operational mapping variables
+└── README.md             # This file
+```
+
+## ⚙️ Configuration
+
+Create a `.env` file in your project root:
+
+```bash
+# Core API Key for the provider (OpenAI, Gemini, Vertex, Groq, etc)
+API_KEY=your_api_key_here
+
+# Base URL for the OpenAI compatible endpoint
+API_BASE_URL=https://api.openai.com/v1
+
+# The model name to use for generating text
+MODEL=gpt-4o
+
+# Tool and Processing Configuration
+MAX_ITERATIONS=25
+
+# Logging Configuration
+LOG_LEVEL=INFO
+```
+
+## 🔌 Using MCP Servers
+
+Add server definitions to your `mcp.json` file in the root directory:
+
+```json
+{
+  "mcpServers": {
+    "sqlite": {
+      "command": "uvx",
+      "args": ["mcp-server-sqlite", "--db-path", "./database.db"],
+      "active": true
+    }
+  }
+}
+```
+
+The framework's `MCPManager` automatically bootstraps all active MCP servers, parses their schemas, and loads their tools natively alongside standard tools upon Agent initialization.
+
+## 🤝 Collaborative Agents
+
+Agents can securely establish communication networks.
+
+```python
+from local_agent_toolkit import Agent
+
+research_agent = Agent("Researcher", "You perform file system research.")
+writer_agent = Agent("Writer", "You answer questions accurately.")
+
+writer_agent.register_collaborator(research_agent)
+
+writer_agent.run("Ask the Researcher to find all text files and read them to me.")
+```
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

nixagent-1.0/__init__.py

@@ -0,0 +1,42 @@
+"""
+Local Agent Toolkit
+
+A sophisticated AI agent toolkit supporting multiple AI providers with tool calling capabilities.
+
+This package provides:
+- AI agents that can use tools to perform tasks
+- Support for Ollama and OpenAI models
+- Command-line interface for interactive use
+- Python library for programmatic use
+
+Quick Start:
+    # Install the package
+    pip install local-agent-toolkit
+    
+    # Use as command line tool
+    local-agent "What files are in the current directory?"
+    
+    # Use as Python library
+    from local_agent_toolkit import run_agent_with_question
+    result, messages = run_agent_with_question("Your question here")
+
+Environment Variables:
+    CURRENT_AGENT: Set to "OLLAMA" or "OPENAI" (default: "OLLAMA")
+    OLLAMA_MODEL: Ollama model name (default: "llama3.1")
+    OLLAMA_BASE_URL: Ollama server URL (default: "http://localhost:11434")
+    OPENAI_API_KEY: OpenAI API key (required for OpenAI agent)
+"""
+
+from helper import run_agent_with_question, tools
+from helper import OllamaAgent, OpenAIAgent
+
+__version__ = "0.1.0"
+__author__ = "TechnicalHeist"
+__email__ = "contact@technicalheist.com"
+
+__all__ = [
+    'run_agent_with_question',
+    'OllamaAgent', 
+    'OpenAIAgent',
+    'tools'
+]

nixagent-1.0/app.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""
+AI Agent Application
+
+This application allows you to interact with an AI agent that can use various tools
+to answer questions and perform tasks. It uses the new generic Agent framework.
+"""
+
+from dotenv import load_dotenv
+load_dotenv()
+
+import sys
+import argparse
+import json
+from nixagent import Agent
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="AI Agent that can use tools to answer questions and perform tasks",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    
+    parser.add_argument('question', nargs='?', help='The question to ask the agent')
+    parser.add_argument('-q', '--question', dest='question_flag', help='Alternative to positional argument')
+    parser.add_argument('--no-save', action='store_true', help='Do not save the conversation history')
+    parser.add_argument('--messages-file', default='messages.json', help='Filename to save history')
+    
+    args = parser.parse_args()
+    
+    question = args.question or args.question_flag
+    
+    # Initialize the core agent
+    agent = Agent(
+        name="Main",
+        system_prompt="You are a highly capable AI assistant that uses available tools to accomplish the user's goals. You must analyze the task carefully and execute the appropriate actions."
+    )
+    
+    if not question:
+        print("🤖 AI Agent - Interactive Mode")
+        print("=" * 50)
+        print("Ask me anything! I can help you with various tasks using my tools.")
+        print("Type 'quit', 'exit', or 'q' to end the session.")
+        print()
+        
+        while True:
+            try:
+                question = input("❓ Your question: ").strip()
+                if question.lower() in ['quit', 'exit', 'q', '']:
+                    print("👋 Goodbye!")
+                    break
+                
+                print("\n🔄 Processing your request...")
+                print("-" * 30)
+                
+                result = agent.run(user_prompt=question)
+                print(f"\n✅ Final Result:\n{result}")
+                
+                if not args.no_save:
+                    with open(args.messages_file, "w") as f:
+                        json.dump(agent.messages, f, indent=2, default=str)
+                    print(f"\n💾 Conversation saved to: {args.messages_file}")
+                
+                print("\n" + "=" * 50)
+                
+            except (KeyboardInterrupt, EOFError):
+                print("\n\n👋 Goodbye!")
+                break
+            except Exception as e:
+                print(f"\n❌ Error: {e}")
+    else:
+        print(f"🤖 AI Agent - Processing: {question}")
+        print("=" * 50)
+        
+        try:
+            result = agent.run(user_prompt=question)
+            print(f"\n✅ Final Result:\n{result}")
+            
+            if not args.no_save:
+                with open(args.messages_file, "w") as f:
+                    json.dump(agent.messages, f, indent=2, default=str)
+                print(f"\n💾 Conversation saved to: {args.messages_file}")
+                
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            sys.exit(1)
+
+if __name__ == "__main__":
+    main()

nixagent-1.0/nixagent/__init__.py

@@ -0,0 +1,5 @@
+from .agent import Agent
+from .llm import call_llm
+from .mcp import MCPManager
+
+__all__ = ["Agent", "call_llm", "MCPManager"]

nixagent-1.0/nixagent/agent.py

@@ -0,0 +1,132 @@
+import os
+import json
+from typing import List, Dict, Any, Callable
+from .llm import call_llm
+from .tools import AVAILABLE_TOOLS, TOOL_DEFINITIONS
+from .mcp import MCPManager
+
+_global_mcp_manager = None
+
+def get_mcp_manager():
+    global _global_mcp_manager
+    if _global_mcp_manager is None:
+        _global_mcp_manager = MCPManager("mcp.json")
+        _global_mcp_manager.load_and_activate()
+    return _global_mcp_manager
+
+class Agent:
+    def __init__(self, name: str, system_prompt: str, model: str = None, 
+                 tools: dict = None, tool_defs: list = None):
+        self.name = name
+        self.system_prompt = system_prompt
+        self.model = model or os.getenv("MODEL", "gpt-4o")
+        self.messages = [{"role": "system", "content": system_prompt}]
+        self.tools = tools if tools is not None else AVAILABLE_TOOLS.copy()
+        self.tool_defs = tool_defs if tool_defs is not None else TOOL_DEFINITIONS.copy()
+        
+        # Load MCP tools
+        mcp = get_mcp_manager()
+        mcp_tools = mcp.get_all_tools()
+        if mcp_tools:
+            self.tool_defs.extend(mcp_tools)
+            for mcp_tool in mcp_tools:
+                mcp_name = mcp_tool["function"]["name"]
+                
+                # Use a factory function to capture the correct mcp_name for the closure
+                def make_mcp_caller(n):
+                    return lambda **kwargs: mcp.call_tool(n, kwargs)
+                    
+                self.tools[mcp_name] = make_mcp_caller(mcp_name)
+
+        self.agents_in_network = {}
+
+    def register_collaborator(self, agent_instance):
+        """Allows agents to talk to each other."""
+        self.agents_in_network[agent_instance.name] = agent_instance
+        # Add a tool to communicate with this agent
+        def communicate_with_agent(message: str) -> str:
+            # Note: We run a sub-agent non-streaming and isolated iterations
+            return agent_instance.run(message, max_iterations=10, stream=False)
+            
+        tool_name = f"ask_agent_{agent_instance.name}"
+        self.tools[tool_name] = communicate_with_agent
+        self.tool_defs.append({
+            "type": "function",
+            "function": {
+                "name": tool_name,
+                "description": f"Ask the {agent_instance.name} agent to perform a task.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "message": {"type": "string", "description": "The task or question for the agent."}
+                    },
+                    "required": ["message"]
+                }
+            }
+        })
+
+    def run(self, user_prompt: str, max_iterations: int = 15, stream: bool = False):
+        self.messages.append({"role": "user", "content": user_prompt})
+        
+        for i in range(max_iterations):
+            print(f"[{self.name}] Iteration {i+1}")
+            try:
+                # Assuming call_llm handles streaming internally. 
+                # For this generic implementation we use standard sync response parsing.
+                # Since task says 'Direct HTTP Requests over SDKs' and 'agnostic to specific use cases'.
+                response = call_llm(
+                    messages=self.messages,
+                    tools=self.tool_defs if self.tool_defs else None,
+                    model=self.model,
+                    stream=False # Stream logic parsing over standard HTTP is complex, focusing on standard payload first
+                )
+                
+                message = response['choices'][0]['message']
+                
+                # Append assistant message
+                self.messages.append(message)
+                
+                if not message.get("tool_calls"):
+                    return message.get("content", "")
+                    
+                for tool_call in message["tool_calls"]:
+                    tool_name = tool_call["function"]["name"]
+                    tool_args_str = tool_call["function"]["arguments"]
+                    try:
+                        tool_args = json.loads(tool_args_str)
+                    except json.JSONDecodeError:
+                        tool_args = {}
+                    
+                    if tool_name not in self.tools:
+                        print(f"[{self.name}] Tool '{tool_name}' not found.")
+                        self.messages.append({
+                            "role": "tool",
+                            "name": tool_name,
+                            "content": f"Error: Tool '{tool_name}' not found.",
+                            "tool_call_id": tool_call["id"]
+                        })
+                        continue
+                        
+                    print(f"[{self.name}] Calling {tool_name}")
+                    try:
+                        tool_output = self.tools[tool_name](**tool_args)
+                        self.messages.append({
+                            "role": "tool",
+                            "name": tool_name,
+                            "content": str(tool_output),
+                            "tool_call_id": tool_call["id"]
+                        })
+                    except Exception as e:
+                        print(f"[{self.name}] Error executing tool '{tool_name}': {e}")
+                        self.messages.append({
+                            "role": "tool",
+                            "name": tool_name,
+                            "content": f"Error executing tool '{tool_name}': {e}",
+                            "tool_call_id": tool_call["id"]
+                        })
+                        
+            except Exception as e:
+                print(f"API error: {e}")
+                return f"API error: {e}"
+                
+        return "Agent could not complete task within limits."

nixagent-1.0/nixagent/llm.py

@@ -0,0 +1,50 @@
+import os
+import json
+import requests
+from typing import List, Dict, Any, Optional
+
+def call_llm(messages: List[Dict], tools: Optional[List[Dict]] = None, 
+             model: Optional[str] = None, api_base: Optional[str] = None, 
+             api_key: Optional[str] = None, provider: str = "openai",
+             stream: bool = False) -> Any:
+    """
+    Execute LLM calls via raw HTTP requests.
+    Supports OpenAI standard format. Many platforms including Ollama support this format.
+    Vertex API support can be routed here as well.
+    """
+    api_key = api_key or os.getenv("API_KEY", "")
+    api_base = api_base or os.getenv("API_BASE_URL", "https://api.openai.com/v1")
+    model = model or os.getenv("MODEL", "gpt-4o")
+    
+    headers = {
+        "Content-Type": "application/json"
+    }
+    
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+        
+    payload = {
+        "model": model,
+        "messages": messages,
+        "temperature": 1,
+        "top_p": 1,
+        "max_tokens": 4096,
+        "stream": stream
+    }
+    
+    if tools:
+        payload["tools"] = tools
+
+    url = f"{api_base.rstrip('/')}/chat/completions"
+    
+    # Custom logic for Vertex if provider == "vertex" might be added here, 
+    # but the task states we standardize exclusively on the OpenAI format for all request structures.
+    
+    if stream:
+        response = requests.post(url, headers=headers, json=payload, stream=True)
+        response.raise_for_status()
+        return response # Return the raw response for iterating lines
+    else:
+        response = requests.post(url, headers=headers, json=payload)
+        response.raise_for_status()
+        return response.json()