agi-mcp-agent

overview

agi-mcp-agent is an open-source intelligent agent framework designed to explore and implement advanced agent capabilities through a master control program (mcp) architecture. this project aims to create a flexible, extensible platform for autonomous agents that can perform complex tasks, learn from interactions, and coordinate multi-agent systems.

visit ot2.net to learn more about our ecosystem and join our community!

vision

our vision is to build a foundational framework for intelligent agents that can:

1. operate autonomously to solve complex problems
2. learn and adapt through interactions with the environment and other agents
3. integrate with various tools, apis, and data sources
4. support multi-agent coordination and communication
5. provide researchers and developers with a flexible platform for ai experimentation

architecture

the agi-mcp-agent architecture consists of several key components:

master control program (mcp)

the central coordination system that:

• manages agent lifecycles
• schedules and prioritizes tasks
• monitors performance and system health
• provides orchestration of multi-agent systems

agent framework

the core agent capabilities:

• cognitive processing (planning, reasoning, decision-making)
• memory management (short-term and long-term)
• tool/api integrations
• perception modules
• action generation
• self-monitoring and reflection

environment interface

• standardized apis for interacting with external systems
• data ingestion pipelines
• output formatting and delivery
• sandboxed execution for security

multi-agent coordination

• communication protocols between agents
• role definition and assignment
• collaborative problem-solving mechanisms
• conflict resolution strategies

roadmap

phase 1: foundation (current)

• core mcp implementation
• basic agent capabilities
• environment interface design
• initial documentation and examples

phase 2: expansion

• advanced cognitive models
• memory optimization
• tool integration framework
• performance benchmarks

phase 3: multi-agent

• agent communication protocols
• collaborative task solving
• specialization and role assignment
• swarm intelligence capabilities

phase 4: applications

• domain-specific agent templates
• real-world use case implementations
• user-friendly interfaces
• enterprise integration options

technical stack

• backend: python

  • fastapi for api interfaces
  • pydantic for data validation
  • sqlalchemy for database interactions
  • langchain for llm orchestration

• frontend: react

  • next.js framework
  • typescript for type safety
  • tailwind css for styling
  • redux for state management

• devops:

  • docker for containerization
  • github actions for ci/cd
  • pytest for testing

getting started

prerequisites

• python 3.8.1 or later
• poetry for dependency management (optional)
• openai api key (for llm-based agents)
• docker and docker compose (optional, for containerized deployment)

local development setup

with poetry (recommended for development)

1. clone the repository

   git clone https://github.com/ot2net/agi-mcp-agent.git
   cd agi-mcp-agent
   

2. install dependencies using poetry

   poetry install
   

3. set up environment variables

   export openai_api_key=your_api_key_here
   

4. run the development server

   poetry run python -m uvicorn agi_mcp_agent.api.server:app --host 0.0.0.0 --port 8000 --reload
   

without poetry (simplified approach)

1. clone the repository

   git clone https://github.com/ot2net/agi-mcp-agent.git
   cd agi-mcp-agent
   

2. generate and install dependencies

   python generate_requirements.py
   pip install -r requirements.txt
   

3. set up environment variables

   export openai_api_key=your_api_key_here
   

4. run the development server

   python -m uvicorn agi_mcp_agent.api.server:app --host 0.0.0.0 --port 8000 --reload
   

using the makefile

the project includes a makefile with useful commands:

make help          # show available commands
make install-dev   # install development dependencies with poetry
make install-pip   # install dependencies with pip (without poetry)
make requirements  # generate requirements.txt from pyproject.toml
make format        # format code with black and isort
make lint          # run linters
make test          # run tests
make run           # run server with poetry
make run-pip       # run server with pip (without poetry)
make docker-build  # build docker image
make docker-run    # run docker container
make docker-stop   # stop docker container

using docker

quick start with docker compose

1. build and run with docker compose

   docker-compose up --build
   

2. access the api at http://localhost:8000

3. stop the containers when done

   docker-compose down
   

custom docker configuration

the project includes two dockerfiles:

• dockerfile - for the backend api
• dockerfile.frontend - for the frontend next.js application

the docker setup automatically extracts dependencies from pyproject.toml and doesn't require poetry to be installed in the container.

to customize the docker build:

1. edit environment variables in docker-compose.yml
2. build the images: docker-compose build
3. run the containers: docker-compose up -d

contributing

we welcome contributions from the community! please check our contributing guidelines to get started.

license

this project is licensed under the mit license - see the license file for details.

connect with us

• ot2.net
• github organization

join our community to discuss ideas, collaborate on development, and help shape the future of intelligent agent systems!