agentkit 0.0.1__tar.gz

agentkit-0.0.1/.gitignore

@@ -0,0 +1,2 @@
+__pycache__
+.DS_Store

agentkit-0.0.1/LICENSE

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

agentkit-0.0.1/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.3
+Name: agentkit
+Version: 0.0.1
+Summary: A simple framework for creating distributed llm agent swarms
+Project-URL: Repository, https://github.com/japanvik/agentkit
+Author-email: Vikram Kumar <vik@japanvik.net>
+License: MIT License
+        
+        Copyright (c) 2024 Vik Kumar
+        
+        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.
+License-File: LICENSE
+Keywords: artificial intelligencs,llm,pubsub
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Requires-Python: >=3.8
+Requires-Dist: fastapi
+Requires-Dist: litellm
+Requires-Dist: pydantic
+Requires-Dist: uvicorn
+Requires-Dist: zmq
+Description-Content-Type: text/markdown
+
+# AgentKit
+
+## Overview
+
+`AgentKit` is a simple framework designed for creating distributed LLM (Large Language Model) agent swarms. It provides an easy-to-use interface for managing communication and data processing among distributed agents, leveraging the power of modern libraries such as `zmq` for messaging, `fastapi` and `uvicorn` for web APIs, `pydantic` for data validation, and `litellm` for language model interactions.
+
+## Installation
+
+Install `AgentKit` using pip:
+
+```bash
+pip install agentkit
+```
+
+Ensure you have Python 3.8 or higher installed to meet the compatibility requirements.
+
+## Quick Start
+
+Look at the examples directory for a simple chat agent. More documentation will come!
+
+## Features
+
+- Easy integration with ZeroMQ for efficient messaging.
+- Web API support through FastAPI and Uvicorn.
+- Robust data validation with Pydantic.
+- Seamless interaction with large language models via Litellm.
+- Designed for scalability and flexibility in distributed environments.
+
+## Documentation
+
+TBD!
+
+## Contributing
+
+We welcome contributions! If you're interested in improving `AgentKit`, please check out our issues section on GitHub.
+
+## License
+
+`AgentKit` is licensed under the MIT License. See the LICENSE file in the source code for more information.

agentkit-0.0.1/README.md

@@ -0,0 +1,39 @@
+# AgentKit
+
+## Overview
+
+`AgentKit` is a simple framework designed for creating distributed LLM (Large Language Model) agent swarms. It provides an easy-to-use interface for managing communication and data processing among distributed agents, leveraging the power of modern libraries such as `zmq` for messaging, `fastapi` and `uvicorn` for web APIs, `pydantic` for data validation, and `litellm` for language model interactions.
+
+## Installation
+
+Install `AgentKit` using pip:
+
+```bash
+pip install agentkit
+```
+
+Ensure you have Python 3.8 or higher installed to meet the compatibility requirements.
+
+## Quick Start
+
+Look at the examples directory for a simple chat agent. More documentation will come!
+
+## Features
+
+- Easy integration with ZeroMQ for efficient messaging.
+- Web API support through FastAPI and Uvicorn.
+- Robust data validation with Pydantic.
+- Seamless interaction with large language models via Litellm.
+- Designed for scalability and flexibility in distributed environments.
+
+## Documentation
+
+TBD!
+
+## Contributing
+
+We welcome contributions! If you're interested in improving `AgentKit`, please check out our issues section on GitHub.
+
+## License
+
+`AgentKit` is licensed under the MIT License. See the LICENSE file in the source code for more information.

agentkit-0.0.1/agentkit/agents/simple_agent.py

@@ -0,0 +1,101 @@
+import asyncio
+import logging
+import requests
+from typing import Any
+from agentkit.messages import Message, MessageType
+from agentkit.network import MessageSender
+from agentkit.handlers import default_handle_helo_message
+
+class SimpleAgent:
+    def __init__(self, config:dict, message_sender: MessageSender, name:str="", description:str=""):
+        self.config:dict = config
+        self.message_sender: MessageSender = message_sender
+        # Get these from instatiation or config
+        self.name:str = self.get_config_value("name", name)
+        self.description:str = self.get_config_value("description", description)
+
+        self.message_queue = asyncio.Queue()
+        self.running = True
+        self.tasks = {}
+        self.message_handlers = {
+            MessageType.HELO: default_handle_helo_message
+        }
+        self.attention: str = "ALL"
+        # Add default tasks
+        self.add_task("message_dispatcher", self.message_dispatcher())
+        self.send_helo()
+
+    def get_config_value(self, parameter_name, override):
+        # 
+        if override:
+            return override
+        else:
+            if parameter_name in self.config['agent'].keys():
+                return self.config['agent'][parameter_name]
+            else:
+                raise ValueError(f'Required Parameter "{parameter_name}" is not defined in the config file or instance creation')
+
+    def add_task(self, task_name, coro):
+        """Add a new task and start it."""
+        if task_name in self.tasks:
+            self.remove_task(task_name)  # Cancel and remove existing task with the same name
+        task = asyncio.create_task(coro)
+        logging.info(f"Starting task:{task_name}")
+        self.tasks[task_name] = task
+
+    async def remove_task(self, task_name):
+        """Cancel and remove a task."""
+        task = self.tasks.pop(task_name, None)
+        if task:
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass  # Task cancellation is expected
+    
+    def add_message_handler(self, message_type:MessageType, handler) -> None:
+        self.message_handlers[message_type] = handler
+        logging.info(f"Added handler for message type: {message_type}")
+        return handler
+            
+    async def stop_all_tasks(self):
+        """Stop all running tasks."""
+        for task_name in list(self.tasks.keys()):
+            await self.remove_task(task_name)
+
+    async def handle_message(self, message: Message) -> Any:
+        logging.info(f"Received message: {message}")
+        await self.message_queue.put(message)
+    
+    async def message_dispatcher(self):
+        while self.running:
+            message = await self.message_queue.get()
+            handler = self.message_handlers.get(message.message_type)
+            if handler:
+                await handler(self, message)
+                await asyncio.sleep(0.1)
+            self.message_queue.task_done()        
+            
+    def is_intended_for_me(self, message: Message) -> bool:
+        # Subscriber Implementation
+        for_me = message.to == self.name or message.to == "ALL"
+        chat_by_me = message.source == self.name and message.message_type == "CHAT" # for storing as history
+        not_my_helo = message.source != self.name and message.message_type == "HELO"
+        return for_me or not_my_helo or chat_by_me
+        
+    def send_helo(self)->requests.Response:
+        """Send the HELO message"""
+        msg = Message(source=self.name, to="ALL", content=self.description, message_type=MessageType.HELO)
+        return self.send_message(msg)
+   
+    def send_message(self, message: Message):
+        return self.message_sender.send_message(message) 
+    
+    async def start(self):
+        while self.running:
+            await asyncio.sleep(1)
+        await self.stop()
+
+    async def stop(self):
+        await self.stop_all_tasks()
+        self.running = False

agentkit-0.0.1/agentkit/brains/simple_brain.py

@@ -0,0 +1,36 @@
+
+from agentkit.memory.memory_protocol import Memory
+from agentkit.messages import Message, MessageType
+from agentkit.processor import llm_processor, remove_emojis
+
+
+class SimpleBrain:
+    def __init__(self, name:str, description:str, model:str, memory_manger:Memory, system_prompt:str="", user_prompt:str="") -> None:
+        self.name = name
+        self.description = description
+        self.model = model
+        self.memory_manager = memory_manger
+        self.system_prompt = system_prompt
+        self.user_prompt = user_prompt
+        
+    async def handle_chat_message(self, agent, message:Message):
+        self.memory_manager.remember(message)
+        if message.source != agent.name:
+            # Reply to a chat message from someone
+            agent.attention = message.source
+            response = await self.create_chat_message(agent)
+            agent.send_message(response)
+
+    async def create_chat_message(self, agent)->Message:
+        """prepare the CHAT message"""
+        context = self.memory_manager.get_chat_context(target=agent.attention)
+        system_prompt = self.system_prompt.format(name=self.name, description=self.description, context=context, target=agent.attention)
+        user_prompt = self.user_prompt.format(name=self.name, description=self.description, context=context, target=agent.attention)
+        reply = await llm_processor(llm_model=self.model, system_prompt=system_prompt, user_prompt=user_prompt, stop=["\n", "<|im_end|>"])
+        # Do some formatting
+        reply = reply.replace(f"{self.name}:", "").strip()
+        reply = reply.replace(f"{agent.attention}:", "").strip()
+        reply = remove_emojis(reply)
+        msg = Message(source=self.name, to=agent.attention, content=reply, message_type=MessageType.CHAT)
+        return msg
+    

agentkit-0.0.1/agentkit/databus.py

@@ -0,0 +1,57 @@
+import asyncio
+import datetime
+
+import zmq
+from fastapi import FastAPI
+
+from agentkit.messages import Message, MessageType
+
+app = FastAPI()
+
+# ZeroMQ Publisher setup
+context = zmq.Context()
+publisher = context.socket(zmq.PUB)
+publisher.bind("tcp://*:5555")  # Allow connections from any IP address
+
+async def send_message(message: Message):
+    try:
+        # Make sure we have a created_at
+        if not message.created_at:
+            message.created_at = datetime.datetime.now().strftime("%a %Y-%m-%d %H:%M:%S")
+        # Send the message to the ZeroMQ publisher channel in JSON format
+        publisher.send_json(message.dict())
+
+        # Return success status
+        return {"status": "success"}
+
+    except Exception as e:
+        # Log the exception
+        print(f"Error sending message: {e}")
+        # Return error status
+        return {"status": "error"}
+
+async def time_publisher_task():
+    while True:
+        current_time = datetime.datetime.now().strftime("%a %Y-%m-%d %H:%M:%S")
+        message = Message(
+            source="TimePublisher",
+            to="ALL",
+            content=f"Current time: {current_time}",
+            created_at=current_time,
+            message_type=MessageType.SYSTEM
+        )
+        await send_message(message)
+        await asyncio.sleep(300)
+
+@app.on_event("startup")
+async def startup_event():
+    asyncio.create_task(time_publisher_task())
+
+@app.post("/data")
+async def post_message(message: Message):
+    # This endpoint calls the same send_message method
+    return await send_message(message)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

agentkit-0.0.1/agentkit/examples/config/simple_chat.json

@@ -0,0 +1,9 @@
+{
+    "agent": {
+        "name": "Julia",
+        "description": "A helpful AI assistant.",
+        "model": "ollama/dolphin-mistral",
+        "system_prompt": "You are an AI agent called {name} who excels at conversations. Your description is as follows: {description}\n You will be given the current history so continue the conversation and be engaged.\nMake your words short and specific.\n",
+        "user_prompt": "Continue the conversation:\n{context}\n{name}:"
+    }
+}

agentkit-0.0.1/agentkit/examples/human_agent.py

@@ -0,0 +1,55 @@
+import argparse
+import asyncio
+import logging
+
+from agentkit.agents.simple_agent import SimpleAgent
+from agentkit.memory.simple_memory import SimpleMemory
+from agentkit.messages import MessageType
+from agentkit.network import HTTPMessageSender, ZMQMessageReceiver
+from agentkit.io import console
+from agentkit.handlers import print_chat_message
+
+# Task definitions
+async def user_input_task(agent):
+    while agent.running:
+        await console.ainput(agent)
+        await asyncio.sleep(0.1)
+
+async def main(name:str, description:str, bus_ip:str="127.0.0.1"):
+    config = {"agent": {"name": name, "description":description, "model": "dummy/dummy"}}
+    agent = SimpleAgent(config=config, message_sender=HTTPMessageSender(publish_address=f"http://{bus_ip}:8000"))
+    # Register the tasks to the agent
+    agent.add_task("user_input", user_input_task(agent))
+    agent.add_message_handler(MessageType.CHAT, print_chat_message)
+   
+    # Initialize the Message Reciever 
+    message_receiver = ZMQMessageReceiver(subscribe_address=f"tcp://{bus_ip}:5555")
+    message_receiver.register_subscriber(agent)
+
+    try:
+        receiver_task = asyncio.create_task(message_receiver.start())
+        agent_task = asyncio.create_task(agent.start())
+        await asyncio.gather(receiver_task, agent_task)
+    except KeyboardInterrupt:
+        logging.info("Ctrl+C pressed. Stopping agent.")
+    except Exception as e:
+        logging.error(f"An error occurred: {e}")
+    finally:
+        # Ensure that stop is called for all the tasks
+        if hasattr(message_receiver, 'stop') and callable(getattr(message_receiver, 'stop')):
+            message_receiver.stop()
+        if hasattr(agent, 'stop') and callable(getattr(agent, 'stop')):
+            await agent.stop()  # If stop is an async method
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Start a console conversational UI for humans")
+    parser.add_argument("--name", help="Name of the Human agent. Default 'Human'", default="Human")
+    parser.add_argument("--description", help="Description of the agent. Introduce yourself to the world. Default 'I am a human agent. Ask me anything!'", default="I am a human agent. Ask me anything!")
+    parser.add_argument("--bus_ip", default="127.0.0.1", help="The IP Address of the bus to subscribe to. Default 127.0.0.1")
+    args = parser.parse_args()
+
+    asyncio.run(main(name=args.name, 
+                     description=args.description, 
+                     bus_ip=args.bus_ip))
+
+    asyncio.run(main())

agentkit-0.0.1/agentkit/examples/simple_chat_agent.py

@@ -0,0 +1,86 @@
+import argparse
+import asyncio
+import json
+import logging
+
+from agentkit.agents.simple_agent import SimpleAgent
+from agentkit.brains.simple_brain import SimpleBrain
+from agentkit.messages import MessageType
+from agentkit.network import HTTPMessageSender, ZMQMessageReceiver
+from agentkit.memory.simple_memory import SimpleMemory
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+
+def load_config(file_path):
+    with open(file_path, 'r') as file:
+        return json.load(file)
+    
+def get_config_value(config, parameter_name, override):
+    # 
+    if override:
+        return override
+    else:
+        if parameter_name in config['agent'].keys():
+            return config['agent'][parameter_name]
+        else:
+            raise ValueError(f'Required Parameter "{parameter_name}" is not defined in the config file or instance creation')
+
+
+async def main(name:str, description:str, config_file:str, model:str, bus_ip:str="127.0.0.1"):
+    # Load the configuration
+    config = load_config(config_file)
+    name=get_config_value(config, "name", name)
+    description=get_config_value(config, "description", description)
+    model = get_config_value(config, "model", model)
+    system_prompt = get_config_value(config, "system_prompt", "")
+    user_prompt = get_config_value(config, "user_prompt", "")
+    
+    agent = SimpleAgent(
+        config=config,
+        name=name,
+        description=description,
+        message_sender=HTTPMessageSender(publish_address=f"http://{bus_ip}:8000"),
+    )
+
+    brain = SimpleBrain(name=name,
+                        description=description,
+                        model=model,
+                        memory_manger=SimpleMemory(max_history_length=6),
+                        system_prompt=system_prompt,
+                        user_prompt=user_prompt
+                        )
+    agent.add_message_handler(MessageType.CHAT, brain.handle_chat_message)
+    
+    message_receiver = ZMQMessageReceiver(subscribe_address=f"tcp://{bus_ip}:5555")
+    message_receiver.register_subscriber(agent)
+
+    try:
+        receiver_task = asyncio.create_task(message_receiver.start())
+        agent_task = asyncio.create_task(agent.start())
+        await asyncio.gather(receiver_task, agent_task)
+    except KeyboardInterrupt:
+        logging.info("Ctrl+C pressed. Stopping agent.")
+    except Exception as e:
+        logging.error(f"An error occurred: {e}")
+    finally:
+        # Ensure that stop is called for all the tasks
+        if hasattr(message_receiver, 'stop') and callable(getattr(message_receiver, 'stop')):
+            message_receiver.stop()
+        if hasattr(agent, 'stop') and callable(getattr(agent, 'stop')):
+            await agent.stop()  # If stop is an async method
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run an agent with specified name and description")
+    parser.add_argument("--config", help="Path to the configuration file", required=True)
+    parser.add_argument("--name", help="Name of the agent. Optional, overriding the config file")
+    parser.add_argument("--description", help="Description of the agent. Optional overriding the config file")
+    parser.add_argument("--model", help="The litellm model you want to use. Optional overriding the config file")
+    parser.add_argument("--bus_ip", default="127.0.0.1", help="The IP Address of the bus to subscribe to. Default 127.0.0.1")
+    args = parser.parse_args()
+
+    asyncio.run(main(name=args.name, 
+                     description=args.description, 
+                     config_file=args.config, 
+                     model=args.model, 
+                     bus_ip=args.bus_ip))

agentkit-0.0.1/agentkit/handlers.py

@@ -0,0 +1,10 @@
+from agentkit.messages import Message, MessageType
+
+async def default_handle_helo_message(agent, message:Message):
+    agent.attention = message.source
+    response = Message(source=agent.name, to=message.source, content=agent.description, message_type=MessageType.ACK)
+    agent.send_message(response)
+        
+async def print_chat_message(agent, message:Message):
+    agent.attention = message.source
+    print(f"\n## {message.source} to {message.to}[{message.message_type}]: {message.content}")

agentkit-0.0.1/agentkit/io/console.py

@@ -0,0 +1,18 @@
+import aioconsole
+from agentkit.messages import Message, MessageType
+
+async def ainput(agent) -> None:
+    prompt = f"##{agent.name} ({agent.attention}):"
+    message = await aioconsole.ainput(prompt)
+    if message != "exit":
+        if not message.startswith("TO:"):
+            destination = agent.attention
+            content = message.strip()
+        else:
+            first_part = message.split(",")[0]
+            content = message.replace(first_part, "").strip()[1:]
+            destination = first_part.replace("TO:", "").strip()
+        msg = Message(source=agent.name, to=destination, content=content, message_type=MessageType.CHAT)
+        agent.message_sender.send_message(msg)
+    else:
+        raise ValueError("Exit was called")

agentkit-0.0.1/agentkit/memory/memory_protocol.py

@@ -0,0 +1,11 @@
+from typing import List, Protocol
+from agentkit.messages import Message
+
+
+class Memory(Protocol):
+    
+    def remember(self, message: Message) -> None:
+        ...
+    
+    def get_history(self) -> List[Message]:
+        ...    

agentkit-0.0.1/agentkit/memory/simple_memory.py

@@ -0,0 +1,23 @@
+
+from agentkit.messages import Message
+
+
+class SimpleMemory:
+    def __init__(self, max_history_length:int=10) -> None:
+        self.history = []
+        self.max_history_length = max_history_length
+
+    def remember(self, message: Message) -> None:
+        # Store the conversation in the history
+        if len(self.history) >= self.max_history_length:
+            self.history.pop(0) # remove oldest message
+        self.history.append(message)
+        
+    def get_history(self) -> list[Message]:
+        return self.history
+    
+    def get_chat_context(self ,target:str, prefix:str="") -> str:
+        chat_log = [x for x in self.get_history() if (target in [x.to, x.source]) and x.message_type=="CHAT"]
+        context =  "\n".join(f"{prefix}{x.source}: {x.content.strip()}" for x in chat_log)
+        return context
+

agentkit-0.0.1/agentkit/messages.py

@@ -0,0 +1,45 @@
+# Pydantic model for request validation
+from datetime import datetime
+from enum import Enum
+from pydantic import BaseModel
+
+class MessageType(str, Enum):
+    HELO = "HELO"# indicating a login or checking if the agent "to" is available 
+    ACK = "ACK" # response to a HELO request. Indicates that the agent is available
+    CHAT = "CHAT" # text message intended for conversation
+    SYSTEM = "SYSTEM" # system message coming from the datahub
+    SENSOR = "SENSOR" # messages for data coming from sensors
+    ERROR = "ERROR" # error messages
+    MEMORY = "MEMORY" # A memory cluster
+    INFO = "INFO" # A response from a previous information request
+
+class Message(BaseModel):
+    """A Message Object that is sent out on the PUB channel of the PUBHUB mechanism.
+    The description of the fields is as follows:
+    source: the source of the message (e.g., the name of the sender, usually another agent or a sensor)
+    to: the intended recipient of the message (e.g., the name of the receiver, usually another agent, or 'ALL' for broadcast)
+    content: the actual message content in string
+    topic: Enum of the topic.
+    created_at: Optional timestamp for when the message was created.
+    """
+    source: str
+    to: str
+    content: str
+    created_at: str
+    message_type: MessageType
+
+    class Config:  
+        use_enum_values = True  
+        
+    def __init__(self, **data):
+        if 'created_at' not in data or data['created_at'] is None:
+            data['created_at'] = datetime.now().strftime("%a %Y-%m-%d %H:%M:%S")
+        super().__init__(**data)
+    
+    def prompt(self):
+        """Print the message in a human-readable format"""
+        return f"source: {self.source}: to: {self.to} ({self.message_type}): {self.content} on {self.created_at})"
+        
+# Pydantic model for response
+class MessageResponse(BaseModel):
+    status: str

agentkit-0.0.1/agentkit/network.py

@@ -0,0 +1,67 @@
+from typing import Any, Protocol
+import requests
+import zmq
+import asyncio
+from agentkit.messages import Message
+
+class Subscriber(Protocol):
+    name: str
+    
+    async def handle_message(self, message: Message) -> Any:
+        ...
+    
+    def is_intended_for_me(self, message: Message) -> bool:
+        ...
+
+class MessageSender(Protocol):
+    def send_message(self, message: Message) -> Any:
+        """Send message out via the network"""
+        ...
+
+
+class ZMQMessageReceiver:
+    def __init__(self, subscribe_address: str="tcp://127.0.0.1:5555"):
+        self.subscribe_address = subscribe_address
+        self.subscribers: list[Subscriber] = []
+        # ZMQ stuff
+        self.context = zmq.Context()
+        self.pubsub_subscriber = self.context.socket(zmq.SUB)
+        self.pubsub_subscriber.setsockopt_string(zmq.SUBSCRIBE, "")
+        self.pubsub_subscriber.connect(subscribe_address)
+        self.running = False
+
+    async def start(self):
+        self.running = True
+        while self.running:
+            try:
+                raw_message = await asyncio.to_thread(self.pubsub_subscriber.recv_json)
+                message = Message.model_validate(raw_message)
+                await self.handle_message(message)
+            except zmq.ZMQError as e:
+                if e.errno != zmq.EAGAIN:
+                    raise
+            except asyncio.CancelledError:
+                # Handle task cancellation gracefully if needed
+                break
+
+    def stop(self):
+        self.running = False
+        self.pubsub_subscriber.close()
+        self.context.term()
+
+    def register_subscriber(self, subscriber: Subscriber):
+        self.subscribers.append(subscriber)
+
+    async def handle_message(self, message: Message):
+        for subscriber in self.subscribers:
+            if subscriber.is_intended_for_me(message):
+                await subscriber.handle_message(message)
+
+
+class HTTPMessageSender:
+    def __init__(self, publish_address: str="http://127.0.0.1:8000") -> None:
+       self.publish_address = publish_address
+    
+    def send_message(self, message: Message) -> requests.Response:
+        response = requests.post(f"{self.publish_address}/data", json=message.dict())
+        return response

agentkit-0.0.1/agentkit/processor.py

@@ -0,0 +1,74 @@
+import json
+import re
+
+from litellm import acompletion, set_verbose
+
+class JSONParseError(ValueError):
+    pass
+    
+
+async def llm_processor(llm_model: str, 
+                    system_prompt: str = "", 
+                    user_prompt: str = "", 
+                    api_base: str = "http://localhost:11434",
+                    stop: list[str] = ["\n"],
+                    ) -> str:
+
+    """
+    A text processor that uses a LLM to generate a response.
+    """
+    set_verbose=True
+    # Use the LLM to generate a response
+    messages=[ {"content": system_prompt, "role": "system"} ]
+    if user_prompt:
+        messages.append({"content": user_prompt, "role": "user"})
+    
+    response = await acompletion(
+        model = llm_model,
+        messages = messages,
+        api_base= api_base,
+        stop=stop
+    )
+    return response.choices[0].message.content.strip()
+
+
+def extract_json(text: str) -> dict:
+    """ Extract the JSON object from the text.
+    :param text: The text to extract the JSON from.
+    :return: The JSON object as a dictionary.
+    """
+    # Extract JSON part from the message
+    json_match = re.search(r"\{.*\}", text, re.DOTALL)
+    if not json_match:
+        raise JSONParseError("No JSON structure was found in your input while parsing. Make sure the JSON formatting is correct.")
+    try:
+        match = json_match.group(0)
+        # convert it to dict
+        #data = ast.literal_eval(match)
+        data = json.loads(match)
+        return data
+    except json.JSONDecodeError:
+        raise JSONParseError(f"Invalid JSON structure: {match}. Make sure the JSON formatting is correct. Always use double quotes and don't use single quotes in your formatting.")
+
+
+def remove_emojis(data):
+    emoj = re.compile("["
+        u"\U0001F600-\U0001F64F"  # emoticons
+        u"\U0001F300-\U0001F5FF"  # symbols & pictographs
+        u"\U0001F680-\U0001F6FF"  # transport & map symbols
+        u"\U0001F1E0-\U0001F1FF"  # flags (iOS)
+        u"\U00002500-\U00002BEF"  # chinese char
+        u"\U00002702-\U000027B0"
+        u"\U000024C2-\U0001F251"
+        u"\U0001f926-\U0001f937"
+        u"\U00010000-\U0010ffff"
+        u"\u2640-\u2642" 
+        u"\u2600-\u2B55"
+        u"\u200d"
+        u"\u23cf"
+        u"\u23e9"
+        u"\u231a"
+        u"\ufe0f"  # dingbats
+        u"\u3030"
+                      "]+", re.UNICODE)
+    return re.sub(emoj, '', data) 

agentkit-0.0.1/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "agentkit"
+version = "0.0.1"
+dependencies = [
+  "zmq",
+  "fastapi",
+  "uvicorn",
+  "pydantic",
+  "litellm"
+]
+requires-python = ">=3.8"
+authors = [
+  {name = "Vikram Kumar", email = "vik@japanvik.net"},
+]
+description = "A simple framework for creating distributed llm agent swarms"
+readme = "README.md"
+license = {file = "LICENSE"}
+keywords = ["artificial intelligencs", "pubsub", "llm"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python"
+]
+[project.urls]
+Repository = "https://github.com/japanvik/agentkit"