Merge pull request #4

Gradio app, planner with interrupt and CI

.env.example

@@ -0,0 +1,4 @@
+MCP_TRELLO_PATH=C:/Users/Matteo/Desktop/dev/trello-mcp-server/main.py
+MCP_GITHUB_PATH=C:/Users/Matteo/Desktop/dev/github-mcp-server/main.py
+
+NEBIUS_API_KEY=

.github/workflows/sync_to_hf.yml

@@ -0,0 +1,20 @@
+name: Sync to Hugging Face hub
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          git remote add space https://huggingface.co/spaces/Agents-MCP-Hackathon/PMCP-AgenticProjectManager   
+          git push -f https://CalleCaje:$HF_TOKEN@huggingface.co/spaces/Agents-MCP-Hackathon/PMCP-AgenticProjectManager

.gitignore

@@ -9,3 +9,4 @@ wheels/
 
 # Virtual environments
 .venv
+.env

README.md

@@ -1,2 +1,16 @@
-# pmcp
-Project Manager with MCP
+---
+title: PMCP AgenticProjectManager
+emoji: ⚡
+colorFrom: yellow
+colorTo: purple
+sdk: gradio
+sdk_version: 5.32.1
+app_file: app.py
+pinned: false
+license: apache-2.0
+short_description: PMCP is an agent that uses MCP to manage a software project
+tags:
+  - agent-demo-track
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -11,172 +11,8 @@ from langgraph.graph import MessagesState, END, StateGraph
 from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
 from langgraph.checkpoint.memory import MemorySaver
 
-SYSTEM_PROMPT = """
-You are an assistant that can manage Trello boards and projects.
-You will be given a set of tools to work with. Each time you decide to use a tool that modifies in any way a Trello board, you MUST ask the user if wants to proceed.
-If the user's answer is negative, then you have to abort everything and end the conversation.
-"""
 
 
-class LangGraphAgent:
-    def __init__(self):
-        self.agent_app = None
-        self.config = {"configurable": {"thread_id": f"{str(uuid.uuid4())}"}}
-        self.memory = MemorySaver()
-
-    def reset_thread(self):
-        """Resets the conversation thread for the agent."""
-        self.config = {"configurable": {"thread_id": f"{str(uuid.uuid4())}"}}
-        print(
-            f"Chat thread reset. New Thread ID: {self.config['configurable']['thread_id']}"
-        )
-
-    async def setup(self):
-        print("Setting up LangGraphAgent...")
-        mcp_client = MultiServerMCPClient(
-            {
-                "trello": {
-                    "url": "http://localhost:8000/sse",
-                    "transport": "sse",
-                }
-            }
-        )
-
-        tools = await mcp_client.get_tools()
-        tool_node = ToolNode(tools)
-
-        # Ensure NEBIUS_API_KEY is set
-        api_key = os.getenv("NEBIUS_API_KEY")
-        if not api_key:
-            raise ValueError("NEBIUS_API_KEY environment variable not set.")
-
-        llm_with_tools = ChatOpenAI(
-            model="meta-llama/Meta-Llama-3.1-8B-Instruct",
-            temperature=0.0,
-            api_key=api_key,
-            base_url="https://api.studio.nebius.com/v1/",
-        )
-        llm_with_tools = llm_with_tools.bind_tools(tools)
-
-        async def call_llm(state: MessagesState):
-            response = await llm_with_tools.ainvoke(
-                state["messages"]
-            )  # Use await for async invoke
-            return {"messages": [response]}
-
-        graph = StateGraph(MessagesState)
-        graph.add_node("llm", functools.partial(call_llm))
-        graph.add_node("tool", tool_node)
-        graph.set_entry_point("llm")
-
-        def should_continue(state: MessagesState):
-            last_message = state["messages"][-1]
-            return (
-                "tool"
-                if hasattr(last_message, "tool_calls") and last_message.tool_calls
-                else END
-            )
-
-        graph.add_conditional_edges("llm", should_continue, {"tool": "tool", END: END})
-        graph.add_edge("tool", "llm")
-
-        self.agent_app = graph.compile(checkpointer=self.memory)
-        print("LangGraphAgent setup complete.")
-
-    async def generate_responses_for_turn(
-        self, user_message_text: str, is_first_turn_in_ui: bool
-    ) -> list[str]:
-        """
-        Generates a list of bot utterances for the current turn based on user input.
-        """
-        langgraph_input_messages = []
-        # The SYSTEM_PROMPT is added to the graph input only if it's the first UI interaction *and*
-        # the checkpointer implies it's the start of a new conversation for the thread_id.
-        # MemorySaver will handle loading history; system prompt is good for first message of a thread.
-
-        # Check current state in memory to decide if SystemMessage is truly needed
-        thread_state = await self.memory.aget(self.config)  # Use aget for async
-        is_new_thread_conversation = (
-            not thread_state
-            or not thread_state.get("values")
-            or not thread_state["values"]["messages"]
-        )
-
-        if is_new_thread_conversation:
-            print("Adding System Prompt for new conversation thread.")
-            langgraph_input_messages.append(
-                SystemMessage(content=SYSTEM_PROMPT.strip())
-            )
-
-        langgraph_input_messages.append(HumanMessage(content=user_message_text))
-
-        bot_responses_this_turn = []
-        processed_message_ids_in_stream = set()
-
-        async for result in self.agent_app.astream(
-            {"messages": langgraph_input_messages},
-            config=self.config,
-            stream_mode="values",
-        ):
-            if not result or "messages" not in result or not result["messages"]:
-                continue
-
-            latest_message_in_graph_state = result["messages"][-1]
-
-            if (
-                isinstance(latest_message_in_graph_state, AIMessage)
-                and latest_message_in_graph_state.id
-                not in processed_message_ids_in_stream
-            ):
-                current_ai_msg = latest_message_in_graph_state
-                # Add message ID to set of processed messages to avoid duplication from multiple stream events
-                # for the same underlying message object.
-                # However, AIMessages can be broken into chunks if streaming content.
-                # For now, with stream_mode="values", we get full messages.
-                # The id check is crucial if the same AIMessage object instance appears multiple times in the stream values.
-
-                newly_generated_content_for_this_step = []
-
-                # 1. Handle AIMessage content
-                if current_ai_msg.content:
-                    # Add content if it's new or different from the last added piece
-                    if (
-                        not bot_responses_this_turn
-                        or bot_responses_this_turn[-1] != current_ai_msg.content
-                    ):
-                        newly_generated_content_for_this_step.append(
-                            str(current_ai_msg.content)
-                        )
-
-                # 2. Handle tool calls
-                if hasattr(current_ai_msg, "tool_calls") and current_ai_msg.tool_calls:
-                    for tool_call in current_ai_msg.tool_calls:
-                        # Check if this specific tool call has been processed (e.g., by ID if available, or by content)
-                        # For simplicity, we assume each tool_call in a new AIMessage is distinct for now
-                        call_str = f"**Tool Call:** `{tool_call['name']}`\n*Arguments:* `{tool_call['args']}`"
-                        newly_generated_content_for_this_step.append(call_str)
-
-                if newly_generated_content_for_this_step:
-                    bot_responses_this_turn.extend(
-                        newly_generated_content_for_this_step
-                    )
-                    processed_message_ids_in_stream.add(
-                        current_ai_msg.id
-                    )  # Mark this AIMessage ID as processed
-
-        # Deduplicate consecutive identical messages that might arise from streaming nuances
-        final_bot_responses = []
-        if bot_responses_this_turn:
-            final_bot_responses.append(bot_responses_this_turn[0])
-            for i in range(1, len(bot_responses_this_turn)):
-                if bot_responses_this_turn[i] != bot_responses_this_turn[i - 1]:
-                    final_bot_responses.append(bot_responses_this_turn[i])
-
-        return final_bot_responses
-
-
-agent = LangGraphAgent()
-
 # Apply a theme
 theme = gr.themes.Soft(
     primary_hue="blue", secondary_hue="sky", neutral_hue="slate"
@@ -191,35 +27,50 @@ theme = gr.themes.Soft(
     button_secondary_text_color="white",
 )
 
-with gr.Blocks(theme=theme, title="Trello AI Assistant") as demo:
+with gr.Blocks(theme=theme, title="PMCP - Agentic Project Management") as demo:
     gr.Markdown(
         """
-        # Trello AI Assistant
-        Manage your Trello boards and projects with AI assistance.
+        # PMCP - Agentic Project Management
+        Manage your projects with AI assistance - GitHub, Trello.
         """
     )
-
-    chatbot = gr.Chatbot(
-        label="Conversation",
-        bubble_full_width=False,
-        height=600,
-        avatar_images=(
-            None,
-            "https://upload.wikimedia.org/wikipedia/commons/thumb/7/72/Brandon_Sanderson_in_2018.jpg/800px-Brandon_Sanderson_in_2018.jpg?20230101015657",
-        ),
-        # (user_avatar, bot_avatar) - replace bot avatar with something better or remove
-    )
-
+    
     with gr.Row():
-        msg = gr.Textbox(
-            label="Your Message",
-            placeholder="Type your message here and press Enter to send...",
-            scale=4,  # Make textbox take more space
-            autofocus=True,
-        )
-        # submit_button = gr.Button("Send", variant="primary", scale=1) # Optional: if you want an explicit send button
+        # Left column for environment variables
+        with gr.Column(scale=1):
+            gr.Markdown("### Environment Variables")
+            github_repo = gr.Textbox(label="GitHub Repo", placeholder="username/repository")
+            github_token = gr.Textbox(label="GitHub Token", placeholder="ghp_xxxxxxxxxxxx", type="password")
+            trello_api = gr.Textbox(label="Trello API", placeholder="Your Trello API key")
+            trello_token = gr.Textbox(label="Trello Token", placeholder="Your Trello token", type="password")
+            hf_token = gr.Textbox(label="HF Token", placeholder="Your Hugging Face token", type="password")
+            
+            set_env_button = gr.Button("Set Environment Variables", variant="primary")
+            env_status = gr.Markdown("")
+            
+        # Right column for chat interface
+        with gr.Column(scale=2):
+            chatbot = gr.Chatbot(
+                label="Conversation",
+                bubble_full_width=False,
+                height=600,
+                avatar_images=(
+                    None,
+                    "https://upload.wikimedia.org/wikipedia/commons/thumb/7/72/Brandon_Sanderson_in_2018.jpg/800px-Brandon_Sanderson_in_2018.jpg?20230101015657",
+                ),
+                # (user_avatar, bot_avatar) - replace bot avatar with something better or remove
+            )
 
-    clear_button = gr.Button("🗑️ Clear Chat & Reset Conversation")
+            with gr.Row():
+                msg = gr.Textbox(
+                    label="Your Message",
+                    placeholder="Type your message here and press Enter to send...",
+                    scale=4,  # Make textbox take more space
+                    autofocus=True,
+                )
+                with gr.Column(scale=1):
+                    submit_button = gr.Button("Send", variant="primary")
+                    clear_button = gr.Button("Reset Conversation", variant="secondary")
 
     async def respond(user_message_text, chat_history):
         if not user_message_text.strip():
@@ -253,14 +104,45 @@ with gr.Blocks(theme=theme, title="Trello AI Assistant") as demo:
 
     # Event handlers
     msg.submit(respond, [msg, chatbot], [chatbot, msg])
-
-    # if submit_button: # If you add explicit send button
-    #     submit_button.click(respond, [msg, chatbot], [chatbot, msg])
+    submit_button.click(respond, [msg, chatbot], [chatbot, msg])
 
     def clear_chat_and_reset_agent():
         agent.reset_thread()
         return [], ""  # Clears chatbot UI and textbox
+    
+    def set_environment_variables(github_repo, github_token, trello_api, trello_token, hf_token):
+        # Set environment variables
+        if github_repo:
+            os.environ["GITHUB_REPO"] = github_repo
+        if github_token:
+            os.environ["GITHUB_TOKEN"] = github_token
+        if trello_api:
+            os.environ["TRELLO_API_KEY"] = trello_api
+        if trello_token:
+            os.environ["TRELLO_TOKEN"] = trello_token
+        if hf_token:
+            os.environ["NEBIUS_API_KEY"] = hf_token
+            
+        # Create a message showing which variables were set
+        set_vars = []
+        if github_repo: set_vars.append("GITHUB_REPO")
+        if github_token: set_vars.append("GITHUB_TOKEN")
+        if trello_api: set_vars.append("TRELLO_API_KEY")
+        if trello_token: set_vars.append("TRELLO_TOKEN")
+        if hf_token: set_vars.append("NEBIUS_API_KEY")
+        
+        if set_vars:
+            return f"✅ Set environment variables: {', '.join(set_vars)}"
+        else:
+            return "⚠️ No environment variables were set"
 
+    # Connect the set environment variables button
+    set_env_button.click(
+        set_environment_variables,
+        inputs=[github_repo, github_token, trello_api, trello_token, hf_token],
+        outputs=[env_status]
+    )
+    
     clear_button.click(clear_chat_and_reset_agent, None, [chatbot, msg], queue=False)
 
     # Load agent setup when the app starts

app_new.py

@@ -0,0 +1,189 @@
+import uuid
+import os
+import gradio as gr
+
+from langchain_core.messages import HumanMessage, AIMessage
+
+# Assuming mcpc_graph.py and its setup_graph function are in the same directory.
+from mcpc_graph import setup_graph
+
+
+async def chat_logic(
+    message,
+    history,
+    session_state,
+    github_repo,
+    github_token,
+    trello_api,
+    trello_token,
+    hf_token,
+):
+    """
+    Handles the main chat logic, including environment setup and streaming responses.
+
+    Args:
+        message (str): The user's input message.
+        history (list): The chat history managed by Gradio.
+        session_state (dict): A dictionary to maintain state across calls for a session.
+        github_repo (str): The GitHub repository (username/repo).
+        github_token (str): The GitHub personal access token.
+        trello_api (str): The Trello API key.
+        trello_token (str): The Trello API token.
+        hf_token (str): The Hugging Face API token.
+
+    Yields:
+        str: The bot's streaming response or an interruption message.
+    """
+    # Retrieve the initialized graph and interrupt handler from the session state.
+    app = session_state.get("app")
+    human_resume_node = session_state.get("human_resume_node")
+
+    # If the graph is not initialized, this is the first message of the session.
+    # We configure the environment and set up the graph.
+    if app is None:
+        # Check if all required fields have been filled out.
+        if not all([github_repo, github_token, trello_api, trello_token, hf_token]):
+            yield "Error: Please provide all API keys and the GitHub repository in the 'API Configuration' section before starting the chat."
+            return
+
+        # Set environment variables for the current process.
+        os.environ["GITHUB_REPO"] = github_repo
+        os.environ["HUGGINGFACE_API_KEY"] = hf_token
+
+        # Asynchronously initialize the graph and store it in the session state
+        # to reuse it for subsequent messages in the same session.
+        app, human_resume_node = await setup_graph(
+            github_token=github_token, trello_api=trello_api, trello_token=trello_token
+        )
+        session_state["app"] = app
+        session_state["human_resume_node"] = human_resume_node
+
+    # Ensure a unique thread_id for the conversation.
+    thread_id = session_state.get("thread_id")
+    if not thread_id:
+        thread_id = str(uuid.uuid4())
+        session_state["thread_id"] = thread_id
+
+    # Check if the current message is a response to a human interruption.
+    is_message_command = session_state.get("is_message_command", False)
+
+    config = {
+        "configurable": {"thread_id": thread_id},
+        "recursion_limit": 100,
+    }
+
+    if is_message_command:
+        # The user is providing feedback to an interruption.
+        app_input = human_resume_node.call_human_interrupt_agent(message)
+        session_state["is_message_command"] = False
+    else:
+        # A standard user message.
+        app_input = {"messages": [HumanMessage(content=message)]}
+
+    # Stream the graph's response.
+    # This revised logic handles intermediate messages and prevents duplication.
+    async for res in app.astream(app_input, config=config, stream_mode="values"):
+        if "messages" in res:
+            last_message = res["messages"][-1]
+            # We only stream content from AIMessages. Any intermediate AIMessages
+            # (e.g., "I will now use a tool") will be overwritten by subsequent
+            # AIMessages in the UI, so only the final answer is visible.
+            if isinstance(last_message, AIMessage):
+                yield last_message.content
+
+        elif "__interrupt__" in res:
+            # Handle interruptions where the agent needs human feedback.
+            interruption_message = res["__interrupt__"][0]
+            session_state["is_message_command"] = True
+            yield interruption_message.value
+            return  # Stop the stream and wait for the user's next message.
+
+
+def create_gradio_app():
+    """Creates and launches the Gradio web application."""
+    print("Launching Gradio app...")
+
+    with gr.Blocks(theme=gr.themes.Soft(), title="LangGraph Multi-Agent Chat") as demo:
+        session_state = gr.State({})
+
+        gr.Markdown(
+            """
+            # LangGraph Multi-Agent Project Manager
+            
+            Interact with a multi-agent system powered by LangGraph.
+            You can assign tasks related to Trello and Github.
+            The system can be interrupted for human feedback when it needs to use a tool.
+            """
+        )
+
+        chatbot = gr.Chatbot(
+            [],
+            elem_id="chatbot",
+            bubble_full_width=False,
+            height=600,
+            label="Multi-Agent Chat",
+            show_label=False,
+        )
+
+        # --- FIX: Added an accordion for API keys and configuration ---
+        with gr.Accordion("API Configuration", open=True):
+            gr.Markdown(
+                "Please enter your credentials. The agent will be configured when you send your first message."
+            )
+            github_repo = gr.Textbox(
+                label="GitHub Repo",
+                placeholder="e.g., username/repository",
+                info="The target repository for GitHub operations.",
+            )
+            github_token = gr.Textbox(
+                label="GitHub Token",
+                placeholder="ghp_xxxxxxxxxxxx",
+                type="password",
+                info="A fine-grained personal access token.",
+            )
+            trello_api = gr.Textbox(
+                label="Trello API Key",
+                placeholder="Your Trello API key",
+                info="Your API key from trello.com/power-ups/admin.",
+            )
+            trello_token = gr.Textbox(
+                label="Trello Token",
+                placeholder="Your Trello token",
+                type="password",
+                info="A token generated from your Trello account.",
+            )
+            hf_token = gr.Textbox(
+                label="Hugging Face Token",
+                placeholder="hf_xxxxxxxxxxxx",
+                type="password",
+                info="Used for tools requiring Hugging Face models.",
+            )
+
+        chat_interface = gr.ChatInterface(
+            fn=chat_logic,
+            chatbot=chatbot,
+            additional_inputs=[
+                session_state,
+                github_repo,
+                github_token,
+                trello_api,
+                trello_token,
+                hf_token,
+            ],
+            title=None,
+            description=None,
+        )
+
+    demo.queue()
+    demo.launch(debug=True)
+
+
+if __name__ == "__main__":
+    try:
+        # The main function to create the app is now synchronous.
+        # Gradio handles the async calls within the chat logic.
+        create_gradio_app()
+    except KeyboardInterrupt:
+        print("\nShutting down Gradio app.")
+    except Exception as e:
+        print(f"An error occurred: {e}")

main.py

@@ -1,6 +1,7 @@
 import os
 import pprint
 import uuid
+from dotenv import load_dotenv
 
 from langchain_mcp_adapters.client import MultiServerMCPClient
 from langchain_openai import ChatOpenAI
@@ -9,13 +10,19 @@ from langgraph.graph import MessagesState, END, StateGraph
 from langchain_core.messages import HumanMessage
 from langgraph.checkpoint.memory import MemorySaver
 
+
 from pmcp.agents.executor import ExecutorAgent
 from pmcp.agents.trello_agent import TrelloAgent
 from pmcp.agents.github_agent import GithubAgent
 from pmcp.agents.planner import PlannerAgent
 
+from pmcp.nodes.human_interrupt_node import HumanInterruptNode
+from pmcp.nodes.human_resume_node import HumanResumeNode
+
 from pmcp.models.state import PlanningState
 
+load_dotenv()
+
 
 async def call_llm(llm_with_tools: ChatOpenAI, state: MessagesState):
     response = llm_with_tools.invoke(state["messages"])
@@ -26,17 +33,18 @@ async def main():
     mcp_client_trello = MultiServerMCPClient(
         {
             "trello": {
-                "url": "http://localhost:8000/sse",
-                "transport": "sse",
+                "command": "python",
+                "args": ["pmcp/mcp_server/trello_server/mcp_trello_main.py"],
+                "transport": "stdio",
             }
         }
     )
-
     mcp_client_github = MultiServerMCPClient(
         {
             "github": {
-                "url": "http://localhost:8002/sse",
-                "transport": "sse",
+                "command": "python",
+                "args": ["pmcp/mcp_server/github_server/mcp_github_main.py"],
+                "transport": "stdio",
             }
         }
     )
@@ -45,6 +53,7 @@ async def main():
 
     trello_tools = await mcp_client_trello.get_tools()
     github_tools = await mcp_client_github.get_tools()
+
     tool_node = ToolNode(github_tools + trello_tools)
 
     llm = ChatOpenAI(
@@ -66,23 +75,30 @@ async def main():
     )
     executor_agent = ExecutorAgent(llm=llm)
 
+    human_interrupt_node = HumanInterruptNode(
+        llm=llm,
+    )
+    human_resume_node = HumanResumeNode(llm=llm)
+
     graph = StateGraph(MessagesState)
     graph.add_node(planner_agent.agent.agent_name, planner_agent.acall_planner_agent)
     graph.add_node(trello_agent.agent.agent_name, trello_agent.acall_trello_agent)
     graph.add_node(github_agent.agent.agent_name, github_agent.acall_github_agent)
     graph.add_node(executor_agent.agent.agent_name, executor_agent.acall_executor_agent)
     graph.add_node("tool", tool_node)
+    graph.add_node("human_interrupt", human_interrupt_node.call_human_interrupt_agent)
     graph.set_entry_point(planner_agent.agent.agent_name)
 
     def should_continue(state: PlanningState):
         last_message = state.messages[-1]
         if last_message.tool_calls:
-            return "tool"
+            return "human_interrupt"
         return executor_agent.agent.agent_name
 
     def execute_agent(state: PlanningState):
         if state.current_step:
             return state.current_step.agent
+
         return END
 
     graph.add_conditional_edges(trello_agent.agent.agent_name, should_continue)
@@ -94,22 +110,38 @@ async def main():
     graph.add_edge(planner_agent.agent.agent_name, executor_agent.agent.agent_name)
 
     app = graph.compile(checkpointer=memory)
-    app.get_graph(xray=True).draw_mermaid_png()
+    app.get_graph(xray=True).draw_mermaid()
 
     user_input = input("user >")
-    config = {"configurable": {"thread_id": f"{str(uuid.uuid4())}"}}
+    config = {
+        "configurable": {"thread_id": f"{str(uuid.uuid4())}"},
+        "recursion_limit": 100,
+    }
 
+    is_message_command = False
     while user_input.lower() != "q":
-        async for res in app.astream(
-            {
+
+        if is_message_command:
+            app_input = human_resume_node.call_human_interrupt_agent(
+                user_input
+            )
+            is_message_command = False
+        else:
+            app_input = {
                 "messages": [
                     HumanMessage(content=user_input),
                 ]
-            },
+            }
+        async for res in app.astream(
+            app_input,
             config=config,
             stream_mode="values",
         ):
-            pprint.pprint(res["messages"][-1])
+            if "messages" in res:
+                pprint.pprint(res["messages"][-1])
+            else:
+                pprint.pprint(res["__interrupt__"][0])
+                is_message_command = True
             pprint.pprint("-------------------------------------")
         user_input = input("user >")
 

mcpc_graph.py

@@ -0,0 +1,112 @@
+import os
+
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from langchain_openai import ChatOpenAI
+from langgraph.prebuilt import ToolNode
+from langgraph.graph import MessagesState, END, StateGraph
+from langgraph.checkpoint.memory import MemorySaver
+
+
+from pmcp.agents.executor import ExecutorAgent
+from pmcp.agents.trello_agent import TrelloAgent
+from pmcp.agents.github_agent import GithubAgent
+from pmcp.agents.planner import PlannerAgent
+
+from pmcp.nodes.human_interrupt_node import HumanInterruptNode
+from pmcp.nodes.human_resume_node import HumanResumeNode
+
+from pmcp.models.state import PlanningState
+
+
+async def setup_graph(github_token: str, trello_api:str, trello_token:str):
+    
+    mcp_client_github = MultiServerMCPClient(
+        {
+            "github": {
+                "command": "python",
+                "args": ["pmcp/mcp_server/github_server/mcp_github_main.py", "--api-key", github_token],
+                "transport": "stdio",
+            }
+        }
+    )
+    
+    
+    mcp_client_trello = MultiServerMCPClient(
+        {
+            "trello": {
+                "command": "python",
+                "args": ["pmcp/mcp_server/trello_server/mcp_trello_main.py", "--api-key", trello_api, "--token", trello_token],
+                "transport": "stdio",
+            }
+        }
+    )
+    
+
+
+    memory = MemorySaver()
+
+    trello_tools = await mcp_client_trello.get_tools()
+    github_tools = await mcp_client_github.get_tools()
+
+    tool_node = ToolNode(github_tools + trello_tools)
+
+    llm = ChatOpenAI(
+        model="Qwen/Qwen2.5-32B-Instruct",
+        temperature=0.0,
+        api_key=os.getenv("NEBIUS_API_KEY"),
+        base_url="https://api.studio.nebius.com/v1/",
+    )
+
+
+    trello_agent = TrelloAgent(
+        tools=trello_tools,
+        llm=llm,
+    )
+
+    github_agent = GithubAgent(llm=llm, tools=github_tools)
+
+    planner_agent = PlannerAgent(
+        llm=llm,
+    )
+    executor_agent = ExecutorAgent(llm=llm)
+
+    human_interrupt_node = HumanInterruptNode(
+        llm=llm,
+    )
+    human_resume_node = HumanResumeNode(llm=llm)
+
+    graph = StateGraph(MessagesState)
+    graph.add_node(planner_agent.agent.agent_name, planner_agent.acall_planner_agent)
+    graph.add_node(trello_agent.agent.agent_name, trello_agent.acall_trello_agent)
+    graph.add_node(github_agent.agent.agent_name, github_agent.acall_github_agent)
+    graph.add_node(executor_agent.agent.agent_name, executor_agent.acall_executor_agent)
+    graph.add_node("tool", tool_node)
+    graph.add_node("human_interrupt", human_interrupt_node.call_human_interrupt_agent)
+    graph.set_entry_point(planner_agent.agent.agent_name)
+
+    def should_continue(state: PlanningState):
+        last_message = state.messages[-1]
+        if last_message.tool_calls:
+            return "human_interrupt"
+        return executor_agent.agent.agent_name
+
+    def execute_agent(state: PlanningState):
+        if state.current_step:
+            return state.current_step.agent
+
+        return END
+
+    graph.add_conditional_edges(trello_agent.agent.agent_name, should_continue)
+    graph.add_conditional_edges(github_agent.agent.agent_name, should_continue)
+    graph.add_conditional_edges(executor_agent.agent.agent_name, execute_agent)
+
+    graph.add_edge("tool", trello_agent.agent.agent_name)
+    graph.add_edge("tool", github_agent.agent.agent_name)
+    graph.add_edge(planner_agent.agent.agent_name, executor_agent.agent.agent_name)
+
+    app = graph.compile(checkpointer=memory)
+    app.get_graph(xray=True).draw_mermaid()
+
+
+
+    return app, human_resume_node

pmcp/agents/executor.py

@@ -31,18 +31,17 @@ class ExecutorAgent:
         }
 
     async def acall_executor_agent(self, state: PlanningState):
-        current_step = state.plan_step
-
-        plan_step = None
-        if len(state.plan.steps) > current_step:
-            plan_step = state.plan.steps[current_step]
-
+        plan_step_index = state.plan_step
+        current_step = None
+        messages = []
+        if len(state.plan.steps) > plan_step_index:
+            current_step = state.plan.steps[plan_step_index]
+            messages = [HumanMessage(
+                    content=f"The {current_step.agent} agent should perform the following action:\n{current_step.description}"
+                )]
+                
         return {
-            "plan_step": current_step + 1,
-            "messages": [
-                HumanMessage(
-                    content=f"The {plan_step.agent} agent should perform the following action:\n{plan_step.description}"
-                )
-            ],
-            "current_step": plan_step,
+            "plan_step": plan_step_index + 1,
+            "messages": messages,
+            "current_step": current_step,
         }

pmcp/agents/github_agent.py

@@ -9,8 +9,7 @@ from pmcp.models.state import PlanningState
 
 SYSTEM_PROMPT = """
 You are an assistant that can manage Trello boards and projects.
-You will be given a set of tools to work with. Each time you decide to use a tool that modifies in any way a Trello board, you MUST ask the user if wants to proceed.
-If the user's answer is negative, then you have to abort everything and end the conversation.
+You will be given a set of tools to work with.
 """
 
 

pmcp/agents/planner.py

@@ -10,8 +10,8 @@ from pmcp.models.state import PlanningState
 
 SYSTEM_PROMPT = """
 You are a Planner Agent responsible for breaking down high-level project goals into clear, actionable steps. You do not execute tasks yourself — instead, you delegate them to two specialized agents:
-- Trello Agent – Handles all operations related to Trello (boards (only read), lists, cards, assignments, due dates, etc.).
-- GitHub Agent – Handles all operations related to GitHub (issues, can see in textual form the repository).
+- TRELLO_AGENT – Handles all operations related to Trello (boards (only read), lists, cards, assignments, due dates, etc.).
+- GITHUB_AGENT – Handles all operations related to GitHub (issues, can see in textual form the repository).
 Your job is to:
 - Analyze the user’s request or project goal.
 - Decompose it into a step-by-step plan with granular, unambiguous tasks.
@@ -42,11 +42,11 @@ class PlannerAgent:
             messages=[SystemMessage(content=self.agent.system_prompt)] + state.messages,
             clazz=Plan,
         )
-        return {"plan": response}
+        return {"plan": response, "plan_step": 0, "current_step": None}
 
     async def acall_planner_agent(self, state: PlanningState):
         response = await self.agent.acall_agent_structured(
             messages=[SystemMessage(content=self.agent.system_prompt)] + state.messages,
             clazz=Plan,
         )
-        return {"plan": response}
+        return {"plan": response, "plan_step": 0, "current_step": None}

pmcp/agents/trello_agent.py

@@ -9,8 +9,7 @@ from pmcp.models.state import PlanningState
 
 SYSTEM_PROMPT = """
 You are an assistant that can manage Trello boards and projects.
-You will be given a set of tools to work with. Each time you decide to use a tool that modifies in any way a Trello board, you MUST ask the user if wants to proceed.
-If the user's answer is negative, then you have to abort everything and end the conversation.
+You will be given a set of tools to work with.
 """
 
 

pmcp/mcp_server/github_server/connection_test.py

@@ -0,0 +1,28 @@
+# client_with_stdio.py
+import asyncio
+from fastmcp import Client
+from fastmcp.client.transports import PythonStdioTransport
+
+async def main():
+
+    transport = PythonStdioTransport(
+        python_cmd="python",                   
+        script_path="mcp_github_main.py",      
+        args=["--api-key", "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"] 
+    )
+
+
+    async with Client(transport) as client:
+        tools = await client.list_tools()
+        print("Available tools:", tools)
+
+        result = await client.call_tool(
+            "get_issues",
+            {"owner": "jlowin", "repo": "fastmcp"}
+        )
+        print("Result:", result)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+

pmcp/mcp_server/github_server/github.py

@@ -0,0 +1,34 @@
+from pmcp.mcp_server.github_server.utils.github_api import GithubClient
+
+
+
+github_client = None
+
+def initialize_github_client(api_key: str = None) -> None:
+    try:
+        if not api_key:
+            raise ValueError(
+                "api_key required"
+            )
+        global github_client 
+        github_client = GithubClient(api_key=api_key)
+    except Exception as e:
+        raise
+
+
+# Add a prompt for common Github operations
+def github_help() -> str:
+    """Provides help information about available Github operations."""
+    return """
+    Available Github Operations:
+    1. get issues
+    2. create issue
+    3. comment issue
+    4. close issue
+    5. get pull requests
+    6. create pull request
+    7. get repo stats
+    8. list branches
+    9. get recent commits
+    10. get file contents
+    """

pmcp/mcp_server/github_server/mcp_github_main.py

@@ -0,0 +1,42 @@
+import logging
+
+import argparse
+from mcp.server.fastmcp import FastMCP
+
+from pmcp.mcp_server.github_server.github import initialize_github_client
+
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Avvia il Github MCP Server")
+    parser.add_argument("--api-key", type=str, required=True, help="API key per GitHub")
+    return parser.parse_args()
+
+def main():
+    args = parse_args()
+
+    initialize_github_client(args.api_key)
+
+    mcp = FastMCP("Github MCP Server")
+    #import here because the client is not initialized yet
+    from pmcp.mcp_server.github_server.tools.tools import register_tools
+    register_tools(mcp)
+
+    try:
+        logger.info("Starting Github MCP Server in Stdio...")
+        mcp.run()
+        logger.info("Github MCP Server started successfully")
+    except KeyboardInterrupt:
+        logger.info("Shutting down server...")
+    except Exception as e:
+        logger.error(f"Server error: {str(e)}")
+        raise
+
+if __name__ == "__main__":
+    main()

pmcp/mcp_server/github_server/models.py

@@ -0,0 +1,20 @@
+from pydantic import BaseModel
+from typing import List
+
+class IssuesList(BaseModel):
+    issues: List[str]
+
+class PullRequestList(BaseModel):
+    pull_requests: List[str]
+
+class BranchList(BaseModel):
+    branches: List[str]
+
+class CommitsList(BaseModel):
+    commits: List[str]
+
+class RepoStats(BaseModel):
+    stars: int
+    forks: int
+    watchers: int
+    open_issues: int

pmcp/mcp_server/github_server/services/branches.py

@@ -0,0 +1,21 @@
+from pmcp.mcp_server.github_server.utils.github_api import GithubClient
+
+
+class BranchService:
+    """Branch enumeration service."""
+
+    def __init__(self, client: GithubClient):
+        self.client = client
+
+    async def list_branches(self, owner: str, repo: str):
+        """
+        Return branch objects for a repository.
+
+        Args:
+            owner (str): Repository owner.
+            repo (str):  Repository name.
+
+        Returns:
+            List of branch dicts (each containing ``name`` and ``commit`` keys).
+        """
+        return await self.client.GET(f"{owner}/{repo}/branches")

pmcp/mcp_server/github_server/services/contents.py

@@ -0,0 +1,44 @@
+from pmcp.mcp_server.github_server.utils.github_api import GithubClient
+
+
+class ContentService:
+    """Commits and file-content helpers."""
+
+    def __init__(self, client: GithubClient):
+        self.client = client
+
+    async def recent_commits(
+        self, owner: str, repo: str, branch: str, per_page: int = 10
+    ):
+        """
+        Retrieve the most recent commits on a branch.
+
+        Args:
+            owner (str):    Repository owner.
+            repo (str):     Repository name.
+            branch (str):   Branch ref (e.g. ``main``).
+            per_page (int): Max commits to return (<=100).
+
+        Returns:
+            List of commit dicts.
+        """
+        params = {"sha": branch, "per_page": per_page}
+        return await self.client.GET(f"{owner}/{repo}/commits", params=params)
+
+    async def get_file(
+        self, owner: str, repo: str, path: str, ref: str | None = None
+    ):
+        """
+        Download a file’s blob (Base64) from a repo.
+
+        Args:
+            owner (str): Repository owner.
+            repo (str):  Repository name.
+            path (str):  File path within the repo.
+            ref (str):   Optional commit SHA / branch / tag.
+
+        Returns:
+            GitHub ``contents`` API response including ``content``.
+        """
+        params = {"ref": ref} if ref else None
+        return await self.client.GET(f"{owner}/{repo}/contents/{path}", params=params)

pmcp/mcp_server/github_server/services/issues.py

@@ -0,0 +1,86 @@
+"""
+Service for managing GitHub issues in the MCP server.
+"""
+from pmcp.mcp_server.github_server.utils.github_api import GithubClient
+
+
+
+class IssueService:
+    """Business-logic layer for issue operations."""
+
+    def __init__(self, client: GithubClient):
+        self.client = client
+
+    # ────────────────────────────────────────────────────────────────── #
+    # READ
+    async def get_issues(self, owner: str, repo: str) -> any:
+        """
+        Return every open-issue JSON object for ``owner/repo``.
+
+        Args:
+            owner (str): Repository owner/organisation.
+            repo (str):  Repository name.
+
+        Returns:
+            any: List of issue dicts exactly as returned by the GitHub REST API.
+        """
+        return await self.client.GET(f"{owner}/{repo}/issues")
+
+    # ────────────────────────────────────────────────────────────────── #
+    # WRITE
+    async def create_issue(
+        self, owner: str, repo: str, title: str, body: str | None = None
+    ):
+        """
+        Create a new issue.
+
+        Args:
+            owner (str): Repository owner.
+            repo (str):  Repository name.
+            title (str): Issue title.
+            body (str):  Optional Markdown body.
+
+        Returns:
+            JSON payload describing the created issue.
+        """
+        payload = {"title": title, "body": body or ""}
+        return await self.client.POST(f"{owner}/{repo}/issues", json=payload)
+
+    async def comment_issue(
+        self, owner: str, repo: str, issue_number: int, body: str
+    ):
+        """
+        Add a comment to an existing issue.
+
+        Args:
+            owner (str):         Repository owner.
+            repo (str):          Repository name.
+            issue_number (int):  Target issue number.
+            body (str):          Comment body (Markdown).
+
+        Returns:
+            JSON with the new comment metadata.
+        """
+        payload = {"body": body}
+        return await self.client.POST(
+            f"{owner}/{repo}/issues/{issue_number}/comments", json=payload
+        )
+
+    async def close_issue(self, owner: str, repo: str, issue_number: int):
+        """
+        Close an issue by setting its state to ``closed``.
+
+        Args:
+            owner (str):        Repository owner.
+            repo (str):         Repository name.
+            issue_number (int): Issue to close.
+
+        Returns:
+            JSON for the updated issue.
+        """
+        payload = {"state": "closed"}
+        return await self.client.PATCH(
+            f"{owner}/{repo}/issues/{issue_number}", json=payload
+        )
+
+

pmcp/mcp_server/github_server/services/pull_requests.py

@@ -0,0 +1,58 @@
+from pmcp.mcp_server.github_server.utils.github_api import GithubClient
+
+
+class PullRequestService:
+    """Read-only pull-request queries."""
+
+    def __init__(self, client: GithubClient):
+        self.client = client
+
+    async def get_pr_list(self, owner: str, repo: str, state: str = "open"):
+        """
+        List pull requests for a repository.
+
+        Args:
+            owner (str): Repository owner.
+            repo (str):  Repository name.
+            state (str): ``open``, ``closed`` or ``all``.
+
+        Returns:
+            List of PR dicts.
+        """
+        params = {"state": state}
+        return await self.client.GET(f"{owner}/{repo}/pulls", params=params)
+
+
+    async def create(
+        self,
+        owner: str,
+        repo: str,
+        title: str,
+        head: str,
+        base: str,
+        body: str | None = None,
+        draft: bool = False,
+    ):
+        """
+        Create a pull request (`POST /pulls`).
+
+        Args:
+            owner: Repository owner.
+            repo:  Repository name.
+            title: PR title.
+            head:  The branch/tag you want to merge **from** (`user:branch` accepted).
+            base:  The branch you want to merge **into** (usually `main`).
+            body:  Optional Markdown description.
+            draft: Whether to open as a draft PR.
+
+        Returns:
+            JSON describing the new pull request.
+        """
+        payload = {
+            "title": title,
+            "head": head,
+            "base": base,
+            "body": body or "",
+            "draft": draft,
+        }
+        return await self.client.POST(f"{owner}/{repo}/pulls", json=payload)

pmcp/mcp_server/github_server/services/repo.py

@@ -0,0 +1,21 @@
+from pmcp.mcp_server.github_server.utils.github_api import GithubClient
+
+
+class RepoService:
+    """General repository information."""
+
+    def __init__(self, client: GithubClient):
+        self.client = client
+
+    async def get_stats(self, owner: str, repo: str):
+        """
+        Fetch high-level repo metadata (stars, forks, etc.).
+
+        Args:
+            owner (str): Repository owner.
+            repo (str):  Repository name.
+
+        Returns:
+            JSON with the repository resource.
+        """
+        return await self.client.GET(f"{owner}/{repo}")

pmcp/mcp_server/github_server/services/repo_to_text.py

@@ -0,0 +1,26 @@
+"""
+Service for managing Github issues in MCP server.
+"""
+from pmcp.mcp_server.github_server.utils.github_api import GithubClient
+
+
+
+class RepoToTextService:
+    """
+    Service class for managing Github repo
+    """
+
+    def __init__(self, client: GithubClient):
+        self.client = client
+
+    async def get_repo_to_text(self, repo: str) -> any:
+        """Retrieves the repo and file structure as text.
+
+        Args:
+            owner (str): The owner of the repository.
+
+        Returns:
+            any: The list of issues.
+        """
+        response = await self.client.REPO_TO_TEXT(repo)
+        return response

pmcp/mcp_server/github_server/tools/__init__.py

@@ -0,0 +1 @@
+

pmcp/mcp_server/github_server/tools/branches.py

@@ -0,0 +1,31 @@
+"""
+Branch listing tool.
+"""
+from typing import List, Dict
+from mcp.server.fastmcp import Context
+from pmcp.mcp_server.github_server.services.branches import BranchService
+from pmcp.mcp_server.github_server.github import github_client
+
+service = BranchService(github_client)
+
+
+async def list_branches(ctx: Context, owner: str, repo: str) -> Dict[str, List[str]]:
+    """
+    Gets the list of branches.
+
+    Args:
+        ctx:   FastMCP request context (handles errors).
+        owner (str): Repository owner.
+        repo (str):  Repository name.
+
+    Returns:
+        {"branches": ["main", "dev", …]}
+    """
+    try:
+        branches = await service.list_branches(owner, repo)
+        names = [b["name"] for b in branches]
+        return {"branches": names}
+    except Exception as exc:
+        error_msg = f"Error while getting the list of branches for repository {repo}. Error: {str(exc)}"
+        await ctx.error(str(exc))
+        raise

pmcp/mcp_server/github_server/tools/contents.py

@@ -0,0 +1,62 @@
+"""
+Commit and file-content tools.
+"""
+import base64
+from typing import List, Dict
+from mcp.server.fastmcp import Context
+from pmcp.mcp_server.github_server.services.contents import ContentService
+from pmcp.mcp_server.github_server.github import github_client
+
+service = ContentService(github_client)
+
+
+async def get_recent_commits(
+    ctx: Context, owner: str, repo: str, branch: str, per_page: int = 10
+) -> Dict[str, List[str]]:
+    """
+    Retrieves the most recent commits.
+
+    Args:
+        ctx:   FastMCP request context (handles errors).
+        owner (str): Repository owner.
+        repo (str):  Repository name.
+        branch (str): Name of the branch
+        per_page (int): Max commits to return
+
+    Returns:
+        {"commits": ["abc123", …]}
+    """
+    try:
+        commits = await service.recent_commits(owner, repo, branch, per_page)
+        shas = [c["sha"] for c in commits]
+        return {"commits": shas}
+    except Exception as exc:
+        error_msg = f"Error while getting the commits for branch {branch} in {repo}. Error {str(exc)}"
+        await ctx.error(str(exc))
+        raise
+
+
+async def get_file_contents(
+    ctx: Context, owner: str, repo: str, path: str, ref: str | None = None
+) -> Dict[str, str]:
+    """
+    Retrieves the most recent commits.
+
+    Args:
+        ctx:   FastMCP request context (handles errors).
+        owner (str): Repository owner.
+        repo (str):  Repository name.
+        path (str): File path within the repo
+        ref (int): Optional commit SHA / branch / tag.
+
+    Returns:
+        {"path": "...", "content": "..."}
+    """
+    try:
+        blob = await service.get_file(owner, repo, path, ref)
+        content = base64.b64decode(blob["content"]).decode()
+        return {"path": path, "content": content}
+    except Exception as exc:
+        error_msg = f"Error while getting the content of file {path} in repository {repo}. Error: {exc}"      
+        await ctx.error(str(error_msg))
+        raise

pmcp/mcp_server/github_server/tools/issues.py

@@ -0,0 +1,111 @@
+"""
+MCP Tools exposing GitHub issue operations.
+"""
+from typing import List, Dict, Any
+from mcp.server.fastmcp import Context
+
+from pmcp.mcp_server.github_server.services.issues import IssueService
+from pmcp.mcp_server.github_server.github import github_client
+
+
+service = IssueService(github_client)
+
+
+# ───────────────────────────────────────────────────────────────────────── #
+# READ
+
+async def get_issues(ctx: Context, owner: str, repo: str) -> Dict[str, List[str]]:
+    """
+    Retrieves issues title and number from repo
+
+    Args:
+        ctx:   FastMCP request context (handles errors).
+        owner (str): Repository owner.
+        repo (str):  Repository name.
+
+    Returns:
+        {"issues": [{"issue_number": 123, "issue_title": "Issue Title"}, ...]}
+    """
+    try:
+        issues = await service.get_issues(owner, repo)
+        # Extract both title and number, skipping pull requests
+        issue_info = [{"issue_number": i["number"], "issue_title": i["title"]} for i in issues if "pull_request" not in i]
+        return {"issues": issue_info}
+    except Exception as exc:
+        error_msg = f"Failed to get issues: {str(exc)}"
+        await ctx.error(str(exc))
+        raise
+
+
+# ───────────────────────────────────────────────────────────────────────── #
+# WRITE
+
+async def create_issue(
+    ctx: Context, owner: str, repo: str, title: str, body: str | None = None
+) -> Dict[str, Any]:
+    """
+    Opens a new issue.
+
+    Args:
+        ctx: FastMCP request context (handles errors).
+        owner (str): Repository owner.
+        repo (str): Repository name.
+        title (str): Issue title.
+        body (str): Body of the issue.
+
+    Returns:
+        {"url": "...", "number": 123}
+    """
+    try:
+        result = await service.create_issue(owner, repo, title, body)
+        return {"url": result["html_url"], "number": result["number"]}
+    except Exception as exc:
+        error_msg = f"Failed to create issue {str(exc)}"
+        await ctx.error(str(exc))
+        raise
+
+
+async def comment_issue(
+    ctx: Context, owner: str, repo: str, issue_number: int, body: str
+) -> Dict[str, str]:
+    """
+    Adds a comment on an existing issue.
+
+    Args:
+        ctx: FastMCP request context (handles errors).
+        owner (str): Repository owner.
+        repo (str): Repository name.
+        issue_number (int): Issue number.
+        body (str): Body of the issue.
+    """
+    try:
+        result = await service.comment_issue(owner, repo, issue_number, body)
+        return {"url": result["html_url"]}
+    except Exception as exc:
+        error_msg = f"Failed to add the comment {str(exc)}"
+        await ctx.error(str(exc))
+        raise
+
+
+async def close_issue(
+    ctx: Context, owner: str, repo: str, issue_number: int
+) -> Dict[str, str]:
+    """
+    Closes an issue.
+
+    Args:
+        ctx: FastMCP request context (handles errors).
+        owner (str): Repository owner.
+        repo (str): Repository name.
+        issue_number (int): Issue number.
+
+    Returns:
+        Dict
+    """
+    try:
+        await service.close_issue(owner, repo, issue_number)
+        return {"status": "closed"}
+    except Exception as exc:
+        error_msg = f"Failed to close the issue number {issue_number} in repo {repo}"
+        await ctx.error(str(exc))
+        raise

pmcp/mcp_server/github_server/tools/pull_requests.py

@@ -0,0 +1,68 @@
+"""
+Pull-request utilities (read-only).
+"""
+from typing import List, Dict
+from mcp.server.fastmcp import Context
+from pmcp.mcp_server.github_server.services.pull_requests import PullRequestService
+from pmcp.mcp_server.github_server.github import github_client
+
+service = PullRequestService(github_client)
+
+
+async def get_pull_requests(
+    ctx: Context, owner: str, repo: str, state: str = "open"
+) -> Dict[str, List[str]]:
+    """
+    Gets the pull requests
+
+    Args:
+        ctx:   FastMCP request context (handles errors).
+        owner (str): Repository owner.
+        repo (str):  Repository name.
+        state (str): State of the pull request
+
+    Returns:
+        {"pull_requests": ["#1 - Add feature (open)", …]}
+    """
+    try:
+        pulls = await service.get_pr_list(owner, repo, state)
+        titles = [f"#{pr['number']} - {pr['title']} ({pr['state']})" for pr in pulls]
+        return {"pull_requests": titles}
+    except Exception as exc:
+        error_msg = f"Failed to get pull requests. Error: {str(exc)}"
+        await ctx.error(str(exc))
+        raise
+
+
+async def create_pull_request(
+    ctx: Context,
+    owner: str,
+    repo: str,
+    title: str,
+    head: str,
+    base: str,
+    body: str | None = None,
+    draft: bool = False,
+) -> Dict[str, str]:
+    """
+    Create a pull request.
+
+    Args:
+        owner: Repository owner.
+        repo:  Repository name.
+        title: PR title.
+        head:  The branch/tag you want to merge **from** (`user:branch` accepted).
+        base:  The branch you want to merge **into** (usually `main`).
+        body:  Optional Markdown description.
+        draft: Whether to open as a draft PR.
+
+    Returns:
+        {"url": pull_request_url, "number": pr_number}
+    """
+    try:
+        pr = await service.create(owner, repo, title, head, base, body, draft)
+        return {"url": pr["html_url"], "number": pr["number"]}
+    except Exception as exc:
+        error_msg = f"Error creating the pull request. Error {str(exc)}"
+        await ctx.error(str(exc))
+        raise

pmcp/mcp_server/github_server/tools/repo.py

@@ -0,0 +1,35 @@
+"""
+Repository-level stats tool.
+"""
+from mcp.server.fastmcp import Context
+from pmcp.mcp_server.github_server.services.repo import RepoService
+from pmcp.mcp_server.github_server.github import github_client
+
+
+service = RepoService(github_client)
+
+
+async def get_repo_stats(ctx: Context, owner: str, repo: str):
+    """
+    Gets the statistics of the repository
+
+    Args:
+        ctx:   FastMCP request context (handles errors).
+        owner (str): Repository owner.
+        repo (str):  Repository name.
+
+    Returns:
+        {"stars": 0, "forks": 0, "watchers": 0, "open_issues": 0}
+    """
+    try:
+        data = await service.get_stats(owner, repo)
+        return {
+            "stars": data["stargazers_count"],
+            "forks": data["forks_count"],
+            "watchers": data["watchers_count"],
+            "open_issues": data["open_issues_count"],
+        }
+    except Exception as exc:
+        error_msg = f"Failed to get statistics of repository {repo}. Error: {str(exc)}"
+        await ctx.error(str(exc))
+        raise

pmcp/mcp_server/github_server/tools/repo_to_text.py

@@ -0,0 +1,28 @@
+"""
+This module contains tools for managing Github.
+"""
+
+from pmcp.mcp_server.github_server.services.repo_to_text import RepoToTextService
+from pmcp.mcp_server.github_server.github import github_client
+
+from mcp.server.fastmcp import Context
+
+
+service = RepoToTextService(github_client)
+
+async def get_repo_to_text(ctx: Context, repo: str) -> str:
+    """Retrieves the repo structure and the repo content as text.
+
+    Args:
+        repo (str): The name of the repository.
+
+    Returns:
+        str: The content of the repository as text.
+    """
+    try:
+        content = await service.get_repo_to_text(repo)
+        return content
+    except Exception as e:
+        error_msg = f"Failed to get content from repo: {str(e)}"
+        await ctx.error(error_msg)
+        raise

pmcp/mcp_server/github_server/tools/tools.py

@@ -0,0 +1,31 @@
+"""
+This module contains tools for managing Github Issues
+"""
+
+from pmcp.mcp_server.github_server.tools import issues, pull_requests, repo, repo_to_text,branches, contents
+
+
+def register_tools(mcp):
+    """Register tools with the MCP server."""
+
+    # ISSUES
+    mcp.add_tool(issues.get_issues)
+    mcp.add_tool(issues.create_issue)
+    mcp.add_tool(issues.comment_issue)
+    mcp.add_tool(issues.close_issue)
+
+    # PULL REQUESTS
+    mcp.add_tool(pull_requests.get_pull_requests)
+    mcp.add_tool(pull_requests.create_pull_request)
+
+    # REPOSITORY
+    mcp.add_tool(repo.get_repo_stats)
+
+    # BRANCHES & COMMITS
+    mcp.add_tool(branches.list_branches)
+    mcp.add_tool(contents.get_recent_commits)
+    mcp.add_tool(contents.get_file_contents)
+
+    
+
+    mcp.add_tool(repo_to_text.get_repo_to_text)

pmcp/mcp_server/github_server/utils/github_api.py

@@ -0,0 +1,67 @@
+import logging
+import httpx
+from pmcp.mcp_server.github_server.utils.repo_to_text_utils import fetch_file_contents, fetch_repo_sha, fetch_repo_tree, format_repo_contents, parse_repo_url
+
+
+GITHUB_API_BASE = "https://api.github.com/repos"
+
+
+class GithubClient:
+    """
+    Client class for interacting with the Github API over REST.
+    """
+
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.base_url = GITHUB_API_BASE
+        self.client = httpx.AsyncClient(base_url=self.base_url)
+
+    async def close(self):
+        await self.client.aclose()
+
+    async def GET(self, endpoint: str, params: dict = None):
+        return await self._request("get", endpoint, params=params)
+
+    async def POST(self, endpoint: str, json: dict):
+        return await self._request("post", endpoint, json=json)
+
+    async def PATCH(self, endpoint: str, json: dict):
+        return await self._request("patch", endpoint, json=json)
+
+    async def PUT(self, endpoint: str, json: dict = None):
+        return await self._request("put", endpoint, json=json)
+
+    async def _request(self, method: str, endpoint: str, **kwargs):
+        headers = self._get_headers()
+
+        try:
+            response = await self.client.request(method, endpoint, headers=headers, **kwargs)
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPStatusError as e:
+            raise httpx.HTTPStatusError(
+                f"Failed to {method.upper()} {endpoint}: {str(e)}",
+                request=e.request,
+                response=e.response,
+            )
+        except httpx.RequestError as e:
+            raise httpx.RequestError(f"Failed to {method.upper()} {endpoint}: {str(e)}")
+
+    def _get_headers(self):
+        return {
+            "Accept": "application/vnd.github+json",
+            "Authorization": f"Bearer {self.api_key}",
+            "X-GitHub-Api-Version": "2022-11-28",
+        }
+    
+    async def REPO_TO_TEXT(self, repo_url: str):
+        owner, repo, ref, path = parse_repo_url(repo_url)
+        sha = fetch_repo_sha(owner, repo, ref, path, self.api_key)
+        tree = fetch_repo_tree(owner, repo, sha, self.api_key)
+        blobs = [item for item in tree if item['type'] == 'blob']
+        common_exts = ('.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.cpp', '.html', '.css')
+        selected_files = [item for item in blobs if item['path'].lower().endswith(common_exts)]
+        for item in selected_files:
+            item['url'] = f"https://api.github.com/repos/{owner}/{repo}/contents/{item['path']}?ref={ref}" if ref else f"https://api.github.com/repos/{owner}/{repo}/contents/{item['path']}"
+        contents = fetch_file_contents(selected_files,self. api_key)
+        return format_repo_contents(contents)

pmcp/mcp_server/github_server/utils/repo_to_text_utils.py

@@ -0,0 +1,83 @@
+import requests
+import re
+import os
+from typing import List, Dict, Tuple
+
+def parse_repo_url(url: str) -> Tuple[str, str, str, str]:
+    url = url.rstrip('/')
+    pattern = r'^https:\/\/github\.com\/([^\/]+)\/([^\/]+)(\/tree\/([^\/]+)(\/(.+))?)?$'
+    match = re.match(pattern, url)
+    if not match:
+        raise ValueError('Invalid GitHub repository URL format.')
+    return match[1], match[2], match[4] or '', match[6] or ''
+
+def fetch_repo_sha(owner: str, repo: str, ref: str, path: str, token: str) -> str:
+    url = f'https://api.github.com/repos/{owner}/{repo}/contents/{path}?ref={ref}' if ref else f'https://api.github.com/repos/{owner}/{repo}/contents/{path}'
+    headers = {'Accept': 'application/vnd.github.object+json'}
+    if token:
+        headers['Authorization'] = f'token {token}'
+    resp = requests.get(url, headers=headers)
+    if resp.status_code == 403 and resp.headers.get('X-RateLimit-Remaining') == '0':
+        raise Exception('GitHub API rate limit exceeded.')
+    if resp.status_code == 404:
+        raise Exception('Repository, branch, or path not found.')
+    if not resp.ok:
+        raise Exception(f'Failed to fetch SHA. Status: {resp.status_code}')
+    return resp.json()['sha']
+
+def fetch_repo_tree(owner: str, repo: str, sha: str, token: str) -> List[Dict]:
+    url = f'https://api.github.com/repos/{owner}/{repo}/git/trees/{sha}?recursive=1'
+    headers = {'Accept': 'application/vnd.github+json'}
+    if token:
+        headers['Authorization'] = f'token {token}'
+    resp = requests.get(url, headers=headers)
+    if resp.status_code == 403 and resp.headers.get('X-RateLimit-Remaining') == '0':
+        raise Exception('GitHub API rate limit exceeded.')
+    if not resp.ok:
+        raise Exception(f'Failed to fetch repo tree. Status: {resp.status_code}')
+    return resp.json()['tree']
+
+def fetch_file_contents(files: List[Dict], token: str) -> List[Dict]:
+    headers = {'Accept': 'application/vnd.github.v3.raw'}
+    if token:
+        headers['Authorization'] = f'token {token}'
+    contents = []
+    for file in files:
+        resp = requests.get(file['url'], headers=headers)
+        if not resp.ok:
+            raise Exception(f'Failed to fetch file: {file["path"]} (status {resp.status_code})')
+        contents.append({'path': file['path'], 'text': resp.text})
+    return contents
+
+def build_tree_structure(paths: List[str]) -> Dict:
+    tree = {}
+    for path in paths:
+        parts = path.split('/')
+        current = tree
+        for i, part in enumerate(parts):
+            if part not in current:
+                current[part] = {} if i < len(parts) - 1 else None
+            current = current[part] if current[part] is not None else {}
+    return tree
+
+def format_tree_index(tree: Dict, prefix: str = '') -> str:
+    output = ''
+    entries = list(tree.items())
+    for i, (name, sub_tree) in enumerate(entries):
+        is_last = i == len(entries) - 1
+        line_prefix = '└── ' if is_last else '├── '
+        child_prefix = '    ' if is_last else '│   '
+        output += f"{prefix}{line_prefix}{name}\n"
+        if sub_tree:
+            output += format_tree_index(sub_tree, prefix + child_prefix)
+    return output
+
+def format_repo_contents(contents: List[Dict]) -> str:
+    contents.sort(key=lambda x: x['path'].lower())
+    paths = [item['path'] for item in contents]
+    tree = build_tree_structure(paths)
+    index = format_tree_index(tree)
+    result = f"Directory Structure:\n\n{index}"
+    for item in contents:
+        result += f"\n\n---\nFile: {item['path']}\n---\n\n{item['text']}\n"
+    return result

pmcp/mcp_server/trello_server/connection_test.py

@@ -0,0 +1,14 @@
+from fastmcp import Client
+
+async def main():
+    # Connect via stdio to a local script
+    async with Client("mcp_trello_main.py") as client:
+        tools = await client.list_tools()
+        print(f"Available tools: {tools}")
+        result = await client.call_tool("get_boards")
+        print(f"Result: {result}")
+
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())

pmcp/mcp_server/trello_server/dtos/update_card.py

@@ -0,0 +1,22 @@
+from pydantic import BaseModel
+
+
+class UpdateCardPayload(BaseModel):
+    """
+    Payload for updating a card.
+
+    Attributes:
+        name (str): The name of the card.
+        desc (str): The description of the card.
+        pos (str | int): The position of the card.
+        closed (bool): Whether the card is closed or not.
+        due (str): The due date of the card in ISO 8601 format.
+        idLabels (str): Comma-separated list of label IDs for the card.
+    """
+
+    name: str | None = None
+    desc: str | None = None
+    pos: str | None = None
+    closed: bool | None = None
+    due: str | None = None
+    idLabels: str | None = None

pmcp/mcp_server/trello_server/mcp_trello_main.py

@@ -0,0 +1,44 @@
+import logging
+import argparse
+from mcp.server.fastmcp import FastMCP
+
+from pmcp.mcp_server.trello_server.trello import initialize_trello_client
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Avvia il Trello MCP Server")
+    parser.add_argument("--api-key", type=str, required=True, help="API key per Trello")
+    parser.add_argument("--token", type=str, required=True, help="Token per Trello")
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    initialize_trello_client(args.api_key, args.token)
+
+    mcp = FastMCP("Trello MCP Server")
+    # import here because the client is not initialized yet
+    from pmcp.mcp_server.trello_server.tools.tools import register_tools
+
+    register_tools(mcp)
+
+    try:
+        logger.info("Starting Trello MCP Server in Stdio...")
+        mcp.run()
+        logger.info("Trello MCP Server started successfully")
+    except KeyboardInterrupt:
+        logger.info("Shutting down server...")
+    except Exception as e:
+        logger.error(f"Server error: {str(e)}")
+        raise
+
+
+if __name__ == "__main__":
+    main()

pmcp/mcp_server/trello_server/models.py

@@ -0,0 +1,47 @@
+from typing import List, Optional
+
+from pydantic import BaseModel
+
+
+class TrelloBoard(BaseModel):
+    """Model representing a Trello board."""
+
+    id: str
+    name: str
+    desc: Optional[str] = None
+    closed: bool = False
+    idOrganization: Optional[str] = None
+    url: str
+
+
+class TrelloList(BaseModel):
+    """Model representing a Trello list."""
+
+    id: str
+    name: str
+    closed: bool = False
+    idBoard: str
+    pos: float
+
+
+class TrelloLabel(BaseModel):
+    """Model representing a Trello label."""
+    
+    id: str
+    name: str
+    color: Optional[str] = None
+
+
+class TrelloCard(BaseModel):
+    """Model representing a Trello card."""
+
+    id: str
+    name: str
+    desc: Optional[str] = None
+    closed: bool = False
+    idList: str
+    idBoard: str
+    url: str
+    pos: float
+    labels: List[TrelloLabel] = []
+    due: Optional[str] = None

pmcp/mcp_server/trello_server/services/board.py

@@ -0,0 +1,53 @@
+"""
+Service for managing Trello boards in MCP server.
+"""
+
+from typing import List
+
+from pmcp.mcp_server.trello_server.models import TrelloBoard, TrelloLabel
+from pmcp.mcp_server.trello_server.utils.trello_api import TrelloClient
+
+
+class BoardService:
+    """
+    Service class for managing Trello boards
+    """
+
+    def __init__(self, client: TrelloClient):
+        self.client = client
+
+    async def get_board(self, board_id: str) -> TrelloBoard:
+        """Retrieves a specific board by its ID.
+
+        Args:
+            board_id (str): The ID of the board to retrieve.
+
+        Returns:
+            TrelloBoard: The board object containing board details.
+        """
+        response = await self.client.GET(f"/boards/{board_id}")
+        return TrelloBoard(**response)
+
+    async def get_boards(self, member_id: str = "me") -> List[TrelloBoard]:
+        """Retrieves all boards for a given member.
+
+        Args:
+            member_id (str): The ID of the member whose boards to retrieve. Defaults to "me" for the authenticated user.
+
+        Returns:
+            List[TrelloBoard]: A list of board objects.
+        """
+        response = await self.client.GET(f"/members/{member_id}/boards")
+        return [TrelloBoard(**board) for board in response]
+
+    async def get_board_labels(self, board_id: str) -> List[TrelloLabel]:
+        """Retrieves all labels for a specific board.
+
+        Args:
+            board_id (str): The ID of the board whose labels to retrieve.
+
+        Returns:
+            List[TrelloLabel]: A list of label objects for the board.
+        """
+        response = await self.client.GET(f"/boards/{board_id}/labels")
+        return [TrelloLabel(**label) for label in response]

pmcp/mcp_server/trello_server/services/card.py

@@ -0,0 +1,84 @@
+"""
+Service for managing Trello cards in MCP server.
+"""
+
+from typing import Any, Dict, List
+
+from pmcp.mcp_server.trello_server.models import TrelloCard
+from pmcp.mcp_server.trello_server.utils.trello_api import TrelloClient
+
+
+class CardService:
+    """
+    Service class for managing Trello cards.
+    """
+
+    def __init__(self, client: TrelloClient):
+        self.client = client
+
+    async def get_card(self, card_id: str) -> TrelloCard:
+        """Retrieves a specific card by its ID.
+
+        Args:
+            card_id (str): The ID of the card to retrieve.
+
+        Returns:
+            TrelloCard: The card object containing card details.
+        """
+        response = await self.client.GET(f"/cards/{card_id}")
+        return TrelloCard(**response)
+
+    async def get_cards(self, list_id: str) -> List[TrelloCard]:
+        """Retrieves all cards in a given list.
+
+        Args:
+            list_id (str): The ID of the list whose cards to retrieve.
+
+        Returns:
+            List[TrelloCard]: A list of card objects.
+        """
+        response = await self.client.GET(f"/lists/{list_id}/cards")
+        return [TrelloCard(**card) for card in response]
+
+    async def create_card(
+        self, list_id: str, name: str, desc: str | None = None
+    ) -> TrelloCard:
+        """Creates a new card in a given list.
+
+        Args:
+            list_id (str): The ID of the list to create the card in.
+            name (str): The name of the new card.
+            desc (str, optional): The description of the new card. Defaults to None.
+
+        Returns:
+            TrelloCard: The newly created card object.
+        """
+        data = {"name": name, "idList": list_id}
+        if desc:
+            data["desc"] = desc
+        response = await self.client.POST("/cards", data=data)
+        return TrelloCard(**response)
+
+    async def update_card(self, card_id: str, **kwargs) -> TrelloCard:
+        """Updates a card's attributes.
+
+        Args:
+            card_id (str): The ID of the card to update.
+            **kwargs: Keyword arguments representing the attributes to update on the card.
+
+        Returns:
+            TrelloCard: The updated card object.
+        """
+        response = await self.client.PUT(f"/cards/{card_id}", data=kwargs)
+        return TrelloCard(**response)
+
+    async def delete_card(self, card_id: str) -> Dict[str, Any]:
+        """Deletes a card.
+
+        Args:
+            card_id (str): The ID of the card to delete.
+
+        Returns:
+            Dict[str, Any]: The response from the delete operation.
+        """
+        return await self.client.DELETE(f"/cards/{card_id}")

pmcp/mcp_server/trello_server/services/checklist.py

@@ -0,0 +1,162 @@
+import logging
+from typing import Dict, List, Optional
+
+from pmcp.mcp_server.trello_server.utils.trello_api import TrelloClient
+
+
+class ChecklistService:
+    """
+    Service class for handling Trello checklist operations.
+    """
+
+    def __init__(self, client: TrelloClient):
+        self.client = client
+
+    async def get_checklist(self, checklist_id: str) -> Dict:
+        """
+        Get a specific checklist by ID.
+
+        Args:
+            checklist_id (str): The ID of the checklist to retrieve
+
+        Returns:
+            Dict: The checklist data
+        """
+        return await self.client.GET(f"/checklists/{checklist_id}")
+
+    async def get_card_checklists(self, card_id: str) -> List[Dict]:
+        """
+        Get all checklists for a specific card.
+
+        Args:
+            card_id (str): The ID of the card to get checklists for
+
+        Returns:
+            List[Dict]: List of checklists on the card
+        """
+        return await self.client.GET(f"/cards/{card_id}/checklists")
+
+    async def create_checklist(
+        self, card_id: str, name: str, pos: Optional[str] = None
+    ) -> Dict:
+        """
+        Create a new checklist on a card.
+
+        Args:
+            card_id (str): The ID of the card to create the checklist on
+            name (str): The name of the checklist
+            pos (Optional[str]): The position of the checklist (top, bottom, or a positive number)
+
+        Returns:
+            Dict: The created checklist data
+        """
+        data = {"name": name}
+        if pos:
+            data["pos"] = pos
+        return await self.client.POST(f"/checklists", data={"idCard": card_id, **data})
+
+    async def update_checklist(
+        self, checklist_id: str, name: Optional[str] = None, pos: Optional[str] = None
+    ) -> Dict:
+        """
+        Update an existing checklist.
+
+        Args:
+            checklist_id (str): The ID of the checklist to update
+            name (Optional[str]): New name for the checklist
+            pos (Optional[str]): New position for the checklist
+
+        Returns:
+            Dict: The updated checklist data
+        """
+        data = {}
+        if name:
+            data["name"] = name
+        if pos:
+            data["pos"] = pos
+        return await self.client.PUT(f"/checklists/{checklist_id}", data=data)
+
+    async def delete_checklist(self, checklist_id: str) -> Dict:
+        """
+        Delete a checklist.
+
+        Args:
+            checklist_id (str): The ID of the checklist to delete
+
+        Returns:
+            Dict: The response from the delete operation
+        """
+        return await self.client.DELETE(f"/checklists/{checklist_id}")
+
+    async def add_checkitem(
+        self,
+        checklist_id: str,
+        name: str,
+        checked: bool = False,
+        pos: Optional[str] = None,
+    ) -> Dict:
+        """
+        Add a new item to a checklist.
+
+        Args:
+            checklist_id (str): The ID of the checklist to add the item to
+            name (str): The name of the checkitem
+            checked (bool): Whether the item is checked
+            pos (Optional[str]): The position of the item
+
+        Returns:
+            Dict: The created checkitem data
+        """
+        data = {"name": name, "checked": checked}
+        if pos:
+            data["pos"] = pos
+        return await self.client.POST(
+            f"/checklists/{checklist_id}/checkItems", data=data
+        )
+
+    async def update_checkitem(
+        self,
+        checklist_id: str,
+        checkitem_id: str,
+        name: Optional[str] = None,
+        checked: Optional[bool] = None,
+        pos: Optional[str] = None,
+    ) -> Dict:
+        """
+        Update a checkitem in a checklist.
+
+        Args:
+            checklist_id (str): The ID of the checklist containing the item
+            checkitem_id (str): The ID of the checkitem to update
+            name (Optional[str]): New name for the checkitem
+            checked (Optional[bool]): New checked state
+            pos (Optional[str]): New position for the item
+
+        Returns:
+            Dict: The updated checkitem data
+        """
+        data = {}
+        if name:
+            data["name"] = name
+        if checked is not None:
+            data["checked"] = checked
+        if pos:
+            data["pos"] = pos
+        return await self.client.PUT(
+            f"/checklists/{checklist_id}/checkItems/{checkitem_id}", data=data
+        )
+
+    async def delete_checkitem(self, checklist_id: str, checkitem_id: str) -> Dict:
+        """
+        Delete a checkitem from a checklist.
+
+        Args:
+            checklist_id (str): The ID of the checklist containing the item
+            checkitem_id (str): The ID of the checkitem to delete
+
+        Returns:
+            Dict: The response from the delete operation
+        """
+        return await self.client.DELETE(
+            f"/checklists/{checklist_id}/checkItems/{checkitem_id}"
+        )

pmcp/mcp_server/trello_server/services/list.py

@@ -0,0 +1,82 @@
+from typing import List
+
+from pmcp.mcp_server.trello_server.models import TrelloList
+from pmcp.mcp_server.trello_server.utils.trello_api import TrelloClient
+
+
+class ListService:
+    """
+    Service class for managing Trello lists.
+    """
+
+    def __init__(self, client: TrelloClient):
+        self.client = client
+
+    # Lists
+    async def get_list(self, list_id: str) -> TrelloList:
+        """Retrieves a specific list by its ID.
+
+        Args:
+            list_id (str): The ID of the list to retrieve.
+
+        Returns:
+            TrelloList: The list object containing list details.
+        """
+        response = await self.client.GET(f"/lists/{list_id}")
+        return TrelloList(**response)
+
+    async def get_lists(self, board_id: str) -> List[TrelloList]:
+        """Retrieves all lists on a given board.
+
+        Args:
+            board_id (str): The ID of the board whose lists to retrieve.
+
+        Returns:
+            List[TrelloList]: A list of list objects.
+        """
+        response = await self.client.GET(f"/boards/{board_id}/lists")
+        return [TrelloList(**list_data) for list_data in response]
+
+    async def create_list(
+        self, board_id: str, name: str, pos: str = "bottom"
+    ) -> TrelloList:
+        """Creates a new list on a given board.
+
+        Args:
+            board_id (str): The ID of the board to create the list in.
+            name (str): The name of the new list.
+            pos (str, optional): The position of the new list. Can be "top" or "bottom". Defaults to "bottom".
+
+        Returns:
+            TrelloList: The newly created list object.
+        """
+        data = {"name": name, "idBoard": board_id, "pos": pos}
+        response = await self.client.POST("/lists", data=data)
+        return TrelloList(**response)
+
+    async def update_list(self, list_id: str, name: str) -> TrelloList:
+        """Updates the name of a list.
+
+        Args:
+            list_id (str): The ID of the list to update.
+            name (str): The new name for the list.
+
+        Returns:
+            TrelloList: The updated list object.
+        """
+        response = await self.client.PUT(f"/lists/{list_id}", data={"name": name})
+        return TrelloList(**response)
+
+    async def delete_list(self, list_id: str) -> TrelloList:
+        """Archives a list.
+
+        Args:
+            list_id (str): The ID of the list to close.
+
+        Returns:
+            TrelloList: The archived list object.
+        """
+        response = await self.client.PUT(
+            f"/lists/{list_id}/closed", data={"value": "true"}
+        )
+        return TrelloList(**response)

pmcp/mcp_server/trello_server/tools/__init__.py

@@ -0,0 +1 @@
+

pmcp/mcp_server/trello_server/tools/board.py

@@ -0,0 +1,68 @@
+"""
+This module contains tools for managing Trello boards.
+"""
+
+import logging
+from typing import List
+
+from mcp.server.fastmcp import Context
+
+from pmcp.mcp_server.trello_server.models import TrelloBoard, TrelloLabel
+from pmcp.mcp_server.trello_server.services.board import BoardService
+from pmcp.mcp_server.trello_server.trello import trello_client
+
+
+
+service = BoardService(trello_client)
+
+
+async def get_board(ctx: Context, board_id: str) -> TrelloBoard:
+    """Retrieves a specific board by its ID.
+
+    Args:
+        board_id (str): The ID of the board to retrieve.
+
+    Returns:
+        TrelloBoard: The board object containing board details.
+    """
+    try:
+        result = await service.get_board(board_id)
+        return result
+    except Exception as e:
+        error_msg = f"Failed to get board: {str(e)}"
+        await ctx.error(error_msg)
+        raise
+
+
+async def get_boards(ctx: Context) -> List[TrelloBoard]:
+    """Retrieves all boards for the authenticated user.
+    Use this method when the user specify only the Board Name and you have to retrieve the Board ID.
+
+    Returns:
+        List[TrelloBoard]: A list of board objects.
+    """
+    try:
+        result = await service.get_boards()
+        return result
+    except Exception as e:
+        error_msg = f"Failed to get boards: {str(e)}"
+        await ctx.error(error_msg)
+        raise
+
+
+async def get_board_labels(ctx: Context, board_id: str) -> List[TrelloLabel]:
+    """Retrieves all labels for a specific board.
+
+    Args:
+        board_id (str): The ID of the board whose labels to retrieve.
+
+    Returns:
+        List[TrelloLabel]: A list of label objects for the board.
+    """
+    try:
+        result = await service.get_board_labels(board_id)
+        return result
+    except Exception as e:
+        error_msg = f"Failed to get board labels: {str(e)}"
+        await ctx.error(error_msg)
+        raise

pmcp/mcp_server/trello_server/tools/card.py

@@ -0,0 +1,115 @@
+"""
+This module contains tools for managing Trello cards.
+"""
+
+import logging
+from typing import List
+
+from mcp.server.fastmcp import Context
+
+from pmcp.mcp_server.trello_server.models import TrelloCard
+from pmcp.mcp_server.trello_server.services.card import CardService
+from pmcp.mcp_server.trello_server.trello import trello_client
+from pmcp.mcp_server.trello_server.dtos.update_card import UpdateCardPayload
+
+
+service = CardService(trello_client)
+
+
+async def get_card(ctx: Context, card_id: str) -> TrelloCard:
+    """Retrieves a specific card by its ID.
+
+    Args:
+        card_id (str): The ID of the card to retrieve.
+
+    Returns:
+        TrelloCard: The card object containing card details.
+    """
+    try:
+        result = await service.get_card(card_id)
+        return result
+    except Exception as e:
+        error_msg = f"Failed to get card: {str(e)}"
+        await ctx.error(error_msg)
+        raise
+
+
+async def get_cards(ctx: Context, list_id: str) -> List[TrelloCard]:
+    """Retrieves all cards in a given list.
+
+    Args:
+        list_id (str): The ID of the list whose cards to retrieve.
+
+    Returns:
+        List[TrelloCard]: A list of card objects.
+    """
+    try:
+        result = await service.get_cards(list_id)
+        return result
+    except Exception as e:
+        error_msg = f"Failed to get cards: {str(e)}"
+        await ctx.error(error_msg)
+        raise
+
+
+async def create_card(
+    ctx: Context, list_id: str, name: str, desc: str | None = None
+) -> TrelloCard:
+    """Creates a new card in a given list.
+
+    Args:
+        list_id (str): The ID of the list to create the card in.
+        name (str): The name of the new card.
+        desc (str, optional): The description of the new card. Defaults to None.
+
+    Returns:
+        TrelloCard: The newly created card object.
+    """
+    try:
+        result = await service.create_card(list_id, name, desc)
+        return result
+    except Exception as e:
+        error_msg = f"Failed to create card: {str(e)}"
+        await ctx.error(error_msg)
+        raise
+
+
+async def update_card(
+    ctx: Context, card_id: str, payload: UpdateCardPayload
+) -> TrelloCard:
+    """Updates a card's attributes.
+
+    Args:
+        card_id (str): The ID of the card to update.
+        **kwargs: Keyword arguments representing the attributes to update on the card.
+
+    Returns:
+        TrelloCard: The updated card object.
+    """
+    try:
+        result = await service.update_card(
+            card_id, **payload.model_dump(exclude_unset=True)
+        )
+        return result
+    except Exception as e:
+        error_msg = f"Failed to update card: {str(e)}"
+        await ctx.error(error_msg)
+        raise
+
+
+async def delete_card(ctx: Context, card_id: str) -> dict:
+    """Deletes a card.
+
+    Args:
+        card_id (str): The ID of the card to delete.
+
+    Returns:
+        dict: The response from the delete operation.
+    """
+    try:
+        result = await service.delete_card(card_id)
+        return result
+    except Exception as e:
+        error_msg = f"Failed to delete card: {str(e)}"
+        await ctx.error(error_msg)
+        raise

pmcp/mcp_server/trello_server/tools/checklist.py

@@ -0,0 +1,139 @@
+"""
+This module contains tools for managing Trello checklists.
+"""
+
+import logging
+from typing import Dict, List, Optional
+
+from pmcp.mcp_server.trello_server.services.checklist import ChecklistService
+from pmcp.mcp_server.trello_server.trello import trello_client
+
+service = ChecklistService(trello_client)
+
+
+async def get_checklist(checklist_id: str) -> Dict:
+    """
+    Get a specific checklist by ID.
+
+    Args:
+        checklist_id (str): The ID of the checklist to retrieve
+
+    Returns:
+        Dict: The checklist data
+    """
+    return await service.get_checklist(checklist_id)
+
+
+async def get_card_checklists(card_id: str) -> List[Dict]:
+    """
+    Get all checklists for a specific card.
+
+    Args:
+        card_id (str): The ID of the card to get checklists for
+
+    Returns:
+        List[Dict]: List of checklists on the card
+    """
+    return await service.get_card_checklists(card_id)
+
+
+async def create_checklist(card_id: str, name: str, pos: Optional[str] = None) -> Dict:
+    """
+    Create a new checklist on a card.
+
+    Args:
+        card_id (str): The ID of the card to create the checklist on
+        name (str): The name of the checklist
+        pos (Optional[str]): The position of the checklist (top, bottom, or a positive number)
+
+    Returns:
+        Dict: The created checklist data
+    """
+    return await service.create_checklist(card_id, name, pos)
+
+
+async def update_checklist(
+    checklist_id: str, name: Optional[str] = None, pos: Optional[str] = None
+) -> Dict:
+    """
+    Update an existing checklist.
+
+    Args:
+        checklist_id (str): The ID of the checklist to update
+        name (Optional[str]): New name for the checklist
+        pos (Optional[str]): New position for the checklist
+
+    Returns:
+        Dict: The updated checklist data
+    """
+    return await service.update_checklist(checklist_id, name, pos)
+
+
+async def delete_checklist(checklist_id: str) -> Dict:
+    """
+    Delete a checklist.
+
+    Args:
+        checklist_id (str): The ID of the checklist to delete
+
+    Returns:
+        Dict: The response from the delete operation
+    """
+    return await service.delete_checklist(checklist_id)
+
+
+async def add_checkitem(
+    checklist_id: str, name: str, checked: bool = False, pos: Optional[str] = None
+) -> Dict:
+    """
+    Add a new item to a checklist.
+
+    Args:
+        checklist_id (str): The ID of the checklist to add the item to
+        name (str): The name of the checkitem
+        checked (bool): Whether the item is checked
+        pos (Optional[str]): The position of the item
+
+    Returns:
+        Dict: The created checkitem data
+    """
+    return await service.add_checkitem(checklist_id, name, checked, pos)
+
+
+async def update_checkitem(
+    checklist_id: str,
+    checkitem_id: str,
+    name: Optional[str] = None,
+    checked: Optional[bool] = None,
+    pos: Optional[str] = None,
+) -> Dict:
+    """
+    Update a checkitem in a checklist.
+
+    Args:
+        checklist_id (str): The ID of the checklist containing the item
+        checkitem_id (str): The ID of the checkitem to update
+        name (Optional[str]): New name for the checkitem
+        checked (Optional[bool]): New checked state
+        pos (Optional[str]): New position for the item
+
+    Returns:
+        Dict: The updated checkitem data
+    """
+    return await service.update_checkitem(
+        checklist_id, checkitem_id, name, checked, pos
+    )
+
+
+async def delete_checkitem(checklist_id: str, checkitem_id: str) -> Dict:
+    """
+    Delete a checkitem from a checklist.
+
+    Args:
+        checklist_id (str): The ID of the checklist containing the item
+        checkitem_id (str): The ID of the checkitem to delete
+
+    Returns:
+        Dict: The response from the delete operation
+    """
+    return await service.delete_checkitem(checklist_id, checkitem_id)