git clone https://github.com/Taofiqq/crewai-composio-mcp-server.git
cd crewai-composio-mcp-server

pip install -r requirements.txt

cp .env.example .env

COMPOSIO_API_KEY=your-composio-api-key
NEBIUS_API_KEY=your-nebius-api-key
TARGET_REPOSITORY=vercel/next-learn
DEFAULT_ATTENDEE_EMAIL=your-email@gmail.com

crewai-composio-mcp-server/
├── agents/                
│   ├── __init__.py
│   ├── github_agent.py   
│   ├── notion_agent.py    
│   └── calendar_agent.py  
├── tasks/                  
│   ├── __init__.py
│   ├── github_tasks.py    
│   ├── notion_tasks.py   
│   └── calendar_tasks.py 
├── workflow/              
│   ├── __init__.py
│   ├── github_workflow.py      
│   ├── notion_workflow.py       
│   ├── calendar_workflow.py    
│   └── full_orchestrator.py    
├── config/                 
│   ├── __init__.py
│   └── settings.py        
├── tools/                  
│   ├── __init__.py
│   └── composio_setup.py  
├── llm/                    
│   ├── __init__.py
│   └── nebius_client.py   
├── mcp_server_wrapper.py   
├── main.py                
├── requirements.txt       
├── .env.example           
├── .gitignore            
└── README.md             

# config/settings.py
import os
from dotenv import load_dotenv

load_dotenv()

class Settings:
    # API Keys
    COMPOSIO_API_KEY = os.getenv("COMPOSIO_API_KEY")
    NEBIUS_API_KEY = os.getenv("NEBIUS_API_KEY")

    # Nebius LLM Configuration
    NEBIUS_MODEL = os.getenv("NEBIUS_MODEL", "meta-llama/Meta-Llama-3.1-8B-Instruct")
    NEBIUS_BASE_URL = os.getenv("NEBIUS_BASE_URL", "https://api.studio.nebius.ai/v1/")

    # Project Configuration
    TARGET_REPOSITORY = os.getenv("TARGET_REPOSITORY", "vercel/next-learn")
    DEFAULT_ATTENDEE_EMAIL = os.getenv("DEFAULT_ATTENDEE_EMAIL", "abumahfuz21@gmail.com")

    # Workflow Settings
    BUG_LABEL = "bug"
    MEETING_DURATION_MINUTES = 30
    ENTITY_ID = "default"

settings = Settings()

# .env
COMPOSIO_API_KEY=your_composio_api_key_here
NEBIUS_API_KEY=your_nebius_api_key_here
NEBIUS_MODEL=meta-llama/Meta-Llama-3.1-8B-Instruct
TARGET_REPOSITORY=vercel/next-learn
DEFAULT_ATTENDEE_EMAIL=your-email@gmail.com

# tools/composio_setup.py
from composio_crewai import ComposioToolSet, App, Action
from config.settings import settings

class ComposioTools:
    def __init__(self):
        self.toolset = ComposioToolSet()
        self.entity_id = settings.ENTITY_ID

    def get_github_tools(self):
        """Get GitHub-specific tools for repository analysis."""
        return self.toolset.get_tools(apps=[App.GITHUB], entity_id=self.entity_id)

    def get_notion_tools(self):
        """Get Notion-specific tools for database management."""
        return self.toolset.get_tools(apps=[App.NOTION], entity_id=self.entity_id)

    def get_calendar_tools(self):
        """Get Google Calendar tools for meeting scheduling."""
        return self.toolset.get_tools(apps=[App.GOOGLECALENDAR], entity_id=self.entity_id)

    def get_specific_actions(self, actions):
        """Get specific Composio actions for targeted functionality."""
        return self.toolset.get_tools(actions=actions, entity_id=self.entity_id)

# Initialize global tools instance
composio_tools = ComposioTools()

# llm/nebius_client.py
import openai
from typing import Dict, Any
import logging
from config.settings import settings

class NebiusClient:
    """Wrapper class for Nebius LLM integration with CrewAI"""

    def __init__(self):
        self.client = openai.OpenAI(
            api_key=settings.NEBIUS_API_KEY, 
            base_url=settings.NEBIUS_BASE_URL
        )
        self.model = settings.NEBIUS_MODEL

    def analyze_labels(self, labels: list) -> Dict[str, Any]:
        """Analyze GitHub issue/PR labels to determine if action is needed"""
        labels_str = ", ".join(labels) if labels else "no labels"

        prompt = f"""
        Analyze these GitHub issue/PR labels: {labels_str}

        Determine:
        1. Is this a bug? (yes/no)
        2. Priority level (low/medium/high/critical)  
        3. Should we schedule a meeting? (yes/no)
        4. Meeting urgency (within 24h/within week/no urgency)

        Respond with ONLY a JSON object.
        """

        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": "You are a GitHub issue analyzer. Respond only with valid JSON."},
                {"role": "user", "content": prompt}
            ],
            max_tokens=200,
            temperature=0.1
        )

        return json.loads(response.choices[0].message.content.strip())

# Global instance
nebius_client = NebiusClient()

# agents/github_agent.py

from crewai import Agent, LLM
from composio_crewai import Action
from tools.composio_setup import composio_tools
from config.settings import settings

class GitHubAgentBuilder:
    def __init__(self):
        self.tools = self._get_github_tools()

    def _get_github_tools(self):
        """Get specific GitHub tools needed for our workflow"""
        github_actions = [
            Action.GITHUB_ISSUES_LIST_FOR_REPO,
            Action.GITHUB_LIST_PULL_REQUESTS,
        ]
        return composio_tools.get_specific_actions(github_actions)

# agents/notion_agent.py
from crewai import Agent, LLM
from composio_crewai import Action
from tools.composio_setup import composio_tools
from config.settings import settings

class NotionAgentBuilder:
    def __init__(self):
        self.tools = self._get_notion_tools()

    def _get_notion_tools(self):
        """Get specific Notion tools for database operations"""
        notion_actions = [
            Action.NOTION_SEARCH_NOTION_PAGE,
            Action.NOTION_CREATE_DATABASE,
            Action.NOTION_INSERT_ROW_DATABASE,
        ]
        return composio_tools.get_specific_actions(notion_actions)

# agents/calendar_agent.py
from crewai import Agent, LLM
from composio_crewai import Action
from tools.composio_setup import composio_tools
from config.settings import settings

class CalendarAgentBuilder:
    def __init__(self):
        self.tools = self._get_calendar_tools()

    def _get_calendar_tools(self):
        """Get specific Google Calendar tools for meeting scheduling"""
        calendar_actions = [Action.GOOGLECALENDAR_CREATE_EVENT]
        return composio_tools.get_specific_actions(calendar_actions)

# tasks/github_tasks.py
from crewai import Task
from agents.github_agent import github_agent
from config.settings import settings

class GitHubTasks:
    @staticmethod
    def fetch_issues_task() -> Task:
        return Task(
            description=f"""
            Fetch the most recent GitHub issues from the {settings.TARGET_REPOSITORY} repository.

            Requirements:
            1. Get at least 10 recent issues (open or closed)
            2. Extract: title, number, state, labels, assignees, created date, author
            3. Focus on issues that might need attention (bugs, critical issues)
            4. Return data in structured format
            """,

# tasks/notion_tasks.py

from crewai import Task
from agents.notion_agent import notion_agent
from config.settings import settings
import logging

# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class NotionTasks:
    """Container class for Notion-related tasks"""

    @staticmethod
    def search_parent_pages_task() -> Task:
        """Task to search for available parent pages in Notion workspace"""

        task = Task(
            description=f"""
            Search for available pages in the Notion workspace to find a parent page for database creation.

            Requirements:
            1. Use NOTION_SEARCH_NOTION_PAGE to search for pages in the workspace
            2. Find any available page that can serve as a parent for database creation
            3. Extract the page ID from the search results
            4. Choose the first available page from the results

            IMPORTANT: Use the exact action name NOTION_SEARCH_NOTION_PAGE

            Focus on finding any page that can be used as a parent for the GitHub database.
            """,

# tasks/calendar_tasks.py
"""
Calendar-specific tasks for bug meeting scheduling
Sends meeting invitations ONLY to abumahfuz21@gmail.com when bugs are detected
"""

from crewai import Task
from agents.calendar_agent import calendar_agent
from config.settings import settings
import logging

# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class CalendarTasks:
    """Container class for Calendar-related bug meeting tasks"""

    @staticmethod
    def detect_bugs_task() -> Task:
        """Task to analyze GitHub data and identify bug-labeled items"""

        task = Task(
            description=f"""
            Analyze the GitHub issues and pull requests data to identify items labeled with '{settings.BUG_LABEL}' or similar critical labels.

            Requirements:
            1. Review all GitHub issues and PRs provided in the context
            2. Identify items specifically labeled with '{settings.BUG_LABEL}', 'critical', 'urgent', or 'security'
            3. Extract key information for each bug:

# workflow/full_orchestrator.py
from crewai import Crew, Process
from agents.github_agent import github_agent
from agents.notion_agent import notion_agent  
from agents.calendar_agent import calendar_agent
from tasks.github_tasks import GitHubTasks
from tasks.notion_tasks import NotionTasks
from tasks.calendar_tasks import CalendarTasks
from config.settings import settings
import logging
from datetime import datetime

class FullGitHubNotionCalendarOrchestrator:
    """Complete GitHub + Notion + Calendar workflow orchestrator"""

    def __init__(self):
        self.github_agent = github_agent
        self.notion_agent = notion_agent
        self.calendar_agent = calendar_agent
        self.tasks = self._setup_tasks()
        self.crew = self._create_crew()

    def _setup_tasks(self):
        """Setup tasks with proper context linking for complete data flow"""

        # Create all task instances
        github_tasks = GitHubTasks()
        notion_tasks = NotionTasks()
        calendar_tasks = CalendarTasks()

# main.py
import argparse
import sys
from datetime import datetime
from workflow.full_orchestrator import run_complete_workflow
from config.settings import settings
import logging

def main():
    parser = argparse.ArgumentParser(description="Analyze GitHub repository and create Notion database")
    parser.add_argument("--repo", type=str, help='GitHub repository in format "owner/repo"', default=None)
    args = parser.parse_args()

# mcp_server_wrapper.py
"""
MCP Server Wrapper for CrewAI + Composio + Nebius Backend
Exposes GitHub analysis workflows as MCP tools via SSE transport
"""

import asyncio
import logging
from typing import Any, Dict, List
from datetime import datetime
import json

# MCP imports - using FastMCP for easier setup
from mcp.server.fastmcp import FastMCP
from mcp.types import Tool, TextContent

# Your existing workflow imports
from workflow.full_orchestrator import run_complete_workflow
from workflow.github_workflow import run_github_workflow
from workflow.notion_workflow import run_notion_workflow_with_data
from workflow.calendar_workflow import run_calendar_bug_workflow_with_data
from config.settings import settings

# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("github-analysis-mcp-server")

# Create FastMCP Server
mcp = FastMCP("github-analysis-backend")

@mcp.tool()
async def analyze_github_repository(
    repository: str, meeting_recipient: str = settings.DEFAULT_ATTENDEE_EMAIL
) -> str:
    """
    Complete GitHub repository analysis with Notion database creation and bug meeting scheduling.

(venv) npx @modelcontextprotocol/inspector
Starting MCP inspector...
⚙️ Proxy server listening on port 6277
🔍 MCP Inspector is up and running at http://127.0.0.1:6274 🚀
New SSE connection. NOTE: The sse transport is deprecated and has been replaced by streamable-http
Query parameters: [Object: null prototype] {
  url: 'http://localhost:8000/sse',
  transportType: 'sse'
}
SSE transport: url=http://localhost:8000/sse, headers=Accept
Connected to SSE transport
Connected MCP client to backing server transport
Created client transport
Created server transport
Set up MCP proxy

npx create-ag-ui-app my-github-analyzer

> CopilotKit/Next.js

> MCP

> No

python mcp_server_wrapper.py

npm run dev