diff --git a/app/cheat-sheet-print.css b/app/cheat-sheet-print.css
index 289a83af0..2c406e3a5 100644
--- a/app/cheat-sheet-print.css
+++ b/app/cheat-sheet-print.css
@@ -135,11 +135,6 @@
font-size: 5.5pt !important;
}
- .cheat-sheet-section .prose code,
- .cheat-sheet-section .markdown code {
- font-size: 5.5pt !important;
- }
-
/* Hide Nextra's terminal UI wrapper */
.my-4.overflow-hidden.rounded-lg.border > .flex.items-center.justify-between {
display: none !important;
@@ -185,6 +180,11 @@
margin: 2pt 0 !important;
}
+ .cheat-sheet-section .prose code,
+ .cheat-sheet-section .markdown code {
+ font-size: 5.5pt !important;
+ }
+
/* Code blocks inside pre elements */
pre code,
.cheat-sheet-section pre code,
diff --git a/app/en/get-started/mcp-clients/_meta.tsx b/app/en/get-started/mcp-clients/_meta.tsx
index c54cd6ef1..ab290a78b 100644
--- a/app/en/get-started/mcp-clients/_meta.tsx
+++ b/app/en/get-started/mcp-clients/_meta.tsx
@@ -23,6 +23,9 @@ const meta: MetaRecord = {
"copilot-studio": {
title: "Microsoft Copilot Studio",
},
+ "github-copilot": {
+ title: "GitHub Copilot",
+ },
};
export default meta;
diff --git a/app/en/get-started/mcp-clients/github-copilot/page.mdx b/app/en/get-started/mcp-clients/github-copilot/page.mdx
new file mode 100644
index 000000000..d0cdc799d
--- /dev/null
+++ b/app/en/get-started/mcp-clients/github-copilot/page.mdx
@@ -0,0 +1,209 @@
+import { Steps, Callout, Tabs } from "nextra/components";
+import { SignupLink } from "@/app/_components/analytics";
+import Image from "next/image";
+
+export const IMAGE_SCALE_FACTOR = 2;
+export const JETBRAINS_START_WIDTH = 318;
+export const JETBRAINS_START_HEIGHT = 184;
+export const VISUAL_STUDIO_STEP_1_WIDTH = 276;
+export const VISUAL_STUDIO_STEP_1_HEIGHT = 120;
+export const VISUAL_STUDIO_STEP_2_WIDTH = 1606;
+export const VISUAL_STUDIO_STEP_2_HEIGHT = 270;
+export const VISUAL_STUDIO_STEP_3_WIDTH = 674;
+export const VISUAL_STUDIO_STEP_3_HEIGHT = 288;
+export const VISUAL_STUDIO_STEP_4_WIDTH = 1070;
+export const VISUAL_STUDIO_STEP_4_HEIGHT = 898;
+export const VISUAL_STUDIO_STEP_5_WIDTH = 660;
+export const VISUAL_STUDIO_STEP_5_HEIGHT = 362;
+export const VISUAL_STUDIO_STEP_6_WIDTH = 1632;
+export const VISUAL_STUDIO_STEP_6_HEIGHT = 360;
+
+# Use Arcade in GitHub Copilot
+
+
+
+
+Connect GitHub Copilot to an Arcade MCP Gateway.
+
+
+
+
+
+1. Create an Arcade account
+2. Get an [Arcade API key](/get-started/setup/api-keys)
+3. Create an [Arcade MCP Gateway](/guides/mcp-gateways) and select the tools you want to use
+
+
+
+
+
+### Set up GitHub Copilot
+
+
+
+ In VS Code, Github Copilot will automatically detect the configured MCP
+ servers. Read the [VS Code
+ instructions](/get-started/mcp-clients/visual-studio-code) to set both of
+ them up.
+
+
+
+ The GitHub Copilot extension for JetBrains IDEs does not currently support remote MCP servers with Dynamic Client Registration. To use an Arcade MCP Gateway with GitHub Copilot on a JetBrains IDE, you must configure the MCP gateway as `Arcade Headers` in the dashboard.
+
+
+ 1. In the lower right corner, click the GitHub Copilot icon.
+ 2. From the menu, select "Open Chat", make sure you are in Agent mode, then click the tools icon.
+ 3. A dialog will open with a list of tools. On the bottom left, click "+ Add More Tools..."
+ 4. This will open the `mcp.json` file in the editor. In the `mcp.json` file, define your MCP servers.
+
+
+
+
+ ```json
+ {
+ "servers": {
+ "mcp-arcade": {
+ "url": "https://api.arcade.dev/mcp/",
+ "requestInit": {
+ "headers": {
+ "Authorization": "Bearer {arcade_api_key}",
+ "Arcade-User-ID": "{arcade_user_id}"
+ }
+ }
+ }
+ }
+ }
+ ```
+
+
+
+ The GitHub Copilot extension for JetBrains IDEs does not currently support remote MCP servers with Dynamic Client Registration. To use an Arcade MCP Gateway with GitHub Copilot on a JetBrains IDE, you must configure the MCP gateway as `Arcade Auth` in the dashboard.
+
+
+
+ Once you save the `mcp.json` file, a start button will appear over the new server name. Click it to start the MCP server.
+
+
+
+ MCP tools are only available in Agent mode.
+
+
+
+
+
+ The GitHub Copilot extension for Visual Studio does not currently support every remote MCP server with Dynamic Client Registration. To use an Arcade MCP Gateway with GitHub Copilot on Visual Studio, you must configure the MCP gateway as `Arcade Headers` in the dashboard.
+
+ In Visual Studio,
+
+ 1. In the upper right corner, click the GitHub Copilot icon.
+
+
+
+ 2. On the bottom of the GitHub Copilot panel, click the tools icon (two wrenches).
+
+
+
+ 3. A dialog will open with a list of tools. On the top right corner of this dialog, click the "+" icon to add a new tool.
+
+
+
+ 4. This will open another dialog. Fill in the information for your MCP server. You will need to choose:
+ - **Destination**: The path to the MCP configuration file, if you choose "Global", the MCP gateway will be added to all solutions. If you choose "Solution", the MCP gateway will be added to the current solution only.
+ - **Server ID**: The ID of the MCP server you're adding, this is how it will be displayed in the list of servers.
+ - **Type**: For MCP gateways, you must select "HTTP".
+ - **URL**: The URL of the MCP gateway.
+ - **Headers**: The headers to pass to the MCP gateway.
+ - Click "Save" to add the MCP server.
+
+
+
+ 5. Once you save the MCP server, it will be added to the list of servers. It will be disabled by default. To enable it, click the checkbox next to the server name.
+
+
+
+ 6. Once the server is enabled, it will be available in the list of tools. If tools are not available, you may need to open the `.mcp.json` file you picked as the destination. Visual Studio will display a "Configure" and "Reconnect" buttons on top of each entry. Clicking "Reconnect" should fix any issues.
+
+
+
+
+
+
+ ```json
+ {
+ "servers": {
+ "mcp-arcade": {
+ "url": "https://api.arcade.dev/mcp/",
+ "headers": {
+ "Authorization": "Bearer {arcade_api_key}",
+ "Arcade-User-ID": "{arcade_user_id}"
+ }
+ }
+ }
+ }
+ ```
+
+
+
+ The GitHub Copilot extension for Visual Studio does not currently support every remote MCP server with Dynamic Client Registration. To use an Arcade MCP Gateway with GitHub Copilot on Visual Studio, you must configure the MCP gateway as `Arcade Headers` in the dashboard.
+
+
+
+
+
+ Coming soon...
+
+
+ Coming soon...
+
+
+
+### Try it out
+
+1. Open the chat pane (typically command-l)
+1. Make sure you are in **Agent** mode
+1. Ask the agent to use a tool.
diff --git a/app/en/home/landing-page.tsx b/app/en/home/landing-page.tsx
index 080df88c8..79ea3f719 100644
--- a/app/en/home/landing-page.tsx
+++ b/app/en/home/landing-page.tsx
@@ -205,10 +205,10 @@ export function LandingPage() {
{/* Search */}
-
+
setSearchQuery("")}
type="button"
>
diff --git a/public/_markdown/en/get-started/agent-frameworks/crewai/custom-auth-flow.md b/public/_markdown/en/get-started/agent-frameworks/crewai/custom-auth-flow.md
new file mode 100644
index 000000000..52dc195e2
--- /dev/null
+++ b/public/_markdown/en/get-started/agent-frameworks/crewai/custom-auth-flow.md
@@ -0,0 +1,147 @@
+---
+title: "Custom Auth Flow with CrewAI"
+description: "Learn how to create a custom auth flow with CrewAI"
+---
+[Agent Frameworks](/en/get-started/agent-frameworks.md)
+[CrewAI](/en/get-started/agent-frameworks/crewai/use-arcade-tools.md)
+Custom auth flow
+
+## Custom Auth Flow with CrewAI
+
+In this guide, we will explore how to create a custom auth flow that will be performed before executing Arcade tools within your CrewAI team.
+
+The `ArcadeToolManager`’s built-in authorization and execution flows work well for many typical use cases. However, some scenarios call for a tailored approach. By implementing a custom auth flow, you gain flexibility in handling tool authorization. If your use case calls for a unique interface, additional approval steps, or specialized error handling, then this guide is for you.
+
+### Prerequisites
+
+- [Obtain an Arcade API key](/get-started/setup/api-keys.md)
+
+
+### Set up your environment
+
+Install the required package, and ensure your environment variables are set with your Arcade and OpenAI :
+
+```bash
+pip install crewai-arcade
+```
+
+### Configure API keys
+
+Provide your Arcade and OpenAI . You can store them in environment variables like so:
+
+```bash
+export ARCADE_API_KEY="your_arcade_api_key"
+export OPENAI_API_KEY="your_openai_api_key"
+```
+
+### Define your custom auth flow
+
+The custom auth flow defined in the following code snippet is a function that will be called whenever CrewAI needs to call a .
+
+```python
+from typing import Any
+
+from crewai_arcade import ArcadeToolManager
+
+USER_ID = "{arcade_user_id}"
+
+def custom_auth_flow(
+ manager: ArcadeToolManager, tool_name: str, **tool_input: dict[str, Any]
+) -> Any:
+ """Custom auth flow for the ArcadeToolManager
+
+ This function is called when CrewAI needs to call a tool that requires authorization.
+ Authorization is handled before executing the tool.
+ This function overrides the ArcadeToolManager's default auth flow performed by ArcadeToolManager.authorize_tool
+ """
+ # Get authorization status
+ auth_response = manager.authorize(tool_name, USER_ID)
+
+ # If the user is not authorized for the tool,
+ # then we need to handle the authorization before executing the tool
+ if not manager.is_authorized(auth_response.id):
+ print(f"Authorization required for tool: '{tool_name}' with inputs:")
+ for input_name, input_value in tool_input.items():
+ print(f" {input_name}: {input_value}")
+ # Handle authorization
+ print(f"\nTo authorize, visit: {auth_response.url}")
+ # Block until the user has completed the authorization
+ auth_response = manager.wait_for_auth(auth_response)
+
+ # Ensure authorization completed successfully
+ if not manager.is_authorized(auth_response.id):
+ raise ValueError(f"Authorization failed for {tool_name}. URL: {auth_response.url}")
+ else:
+ print(f"Authorization already granted for tool: '{tool_name}' with inputs:")
+ for input_name, input_value in tool_input.items():
+ print(f" {input_name}: {input_value}")
+
+
+def tool_manager_callback(tool_manager: ArcadeToolManager, tool_name: str, **tool_input: dict[str, Any]) -> Any:
+ """Tool executor callback with custom auth flow for the ArcadeToolManager
+
+ ArcadeToolManager's default executor handles authorization and tool execution.
+ This function overrides the default executor to handle authorization in a custom way and then executes the tool.
+ """
+ custom_auth_flow(tool_manager, tool_name, **tool_input)
+ return tool_manager.execute_tool(USER_ID, tool_name, **tool_input)
+```
+
+### Get Arcade tools
+
+You can now provide the manager callback to the `ArcadeToolManager` upon initialization:
+
+```python
+# Provide the tool manager callback to the ArcadeToolManager
+manager = ArcadeToolManager(executor=tool_manager_callback)
+
+# Retrieve the provided tools and/or MCP Servers as CrewAI StructuredTools.
+tools = manager.get_tools(tools=["Gmail.ListEmails"], toolkits=["Slack"])
+```
+
+### Use tools in your CrewAI agent team
+
+Create a Crew that uses your tools with the custom auth flow. When the is called, your tool manager callback will be called to handle the authorization and then the tool will be executed.
+
+```python
+from crewai import Agent, Crew, Task
+from crewai.llm import LLM
+
+crew_agent = Agent(
+ role="Main Agent",
+ backstory="You are a helpful assistant",
+ goal="Help the user with their requests",
+ tools=tools,
+ allow_delegation=False,
+ verbose=True,
+ llm=LLM(model="gpt-4o"),
+)
+
+task = Task(
+ description="Get the 5 most recent emails from the user's inbox and summarize them and recommend a response for each.",
+ expected_output="A bulleted list with a one sentence summary of each email and a recommended response to the email.",
+ agent=crew_agent,
+ tools=crew_agent.tools,
+)
+
+crew = Crew(
+ agents=[crew_agent],
+ tasks=[task],
+ verbose=True,
+ memory=True,
+)
+
+result = crew.kickoff()
+
+print("\n\n\n ------------ Result ------------ \n\n\n")
+print(result)
+```
+
+## Next steps
+
+Now you’re ready to integrate Arcade tools with a custom auth flow into your own CrewAI team.
+
+Last updated on February 10, 2026
+
+[Using Arcade tools](/en/get-started/agent-frameworks/crewai/use-arcade-tools.md)
+[Overview](/en/get-started/agent-frameworks/google-adk/overview.md)
diff --git a/public/_markdown/en/get-started/agent-frameworks/crewai/use-arcade-tools.md b/public/_markdown/en/get-started/agent-frameworks/crewai/use-arcade-tools.md
index 96f3b54ff..5ef2ce7d5 100644
--- a/public/_markdown/en/get-started/agent-frameworks/crewai/use-arcade-tools.md
+++ b/public/_markdown/en/get-started/agent-frameworks/crewai/use-arcade-tools.md
@@ -2,31 +2,31 @@
title: "Setup Arcade tools with CrewAI"
description: "Learn how to use Arcade tools in CrewAI applications"
---
+
[Agent Frameworks](/en/get-started/agent-frameworks.md)
CrewAISetup Arcade tools with CrewAI
# Use Arcade tools with CrewAI
-[CrewAI](https://www.crewai.com/) is an agentic framework optimized for building task-oriented multi- systems. This guide explains how to integrate Arcade into your CrewAI applications.
+[CrewAI](https://www.crewai.com/) is an agentic framework optimized for building task-oriented multi- systems. This guide explains how to integrate Arcade into your CrewAI applications.
## Outcomes
-You will build a CrewAI that uses Arcade to help with Gmail and Slack.
+You will build a CrewAI that uses Arcade to help with Gmail and Slack.
### You will Learn
-- How to retrieve Arcade and convert them to CrewAI format
-- How to build a CrewAI with Arcade
-- How to implement “just in time” (JIT) authorization using Arcade’s client
+- How to retrieve Arcade and convert them to CrewAI format
+- How to build a CrewAI with Arcade
+- How to implement “just in time” (JIT) authorization using Arcade’s client
### Prerequisites
-- [Arcade account](https://app.arcade.dev/register)
-
-- [Obtain an Arcade API key](/get-started/setup/api-keys.md)
+- [Arcade account](https://app.arcade.dev/register)
-- The [`uv` package manager](https://docs.astral.sh/uv/)
+- [Obtain an Arcade API key](/get-started/setup/api-keys.md)
+- The [`uv` package manager](https://docs.astral.sh/uv/)
## The agent architecture you will build in this guide
@@ -36,7 +36,7 @@ CrewAI provides a [Crew](https://docs.crewai.com/reference/crew) class that im
### Create a new project
-Create a new directory for your and initialize a new virtual environment:
+Create a new directory for your and initialize a new virtual environment:
```bash
mkdir crewai-arcade-example
@@ -84,22 +84,22 @@ import os
This includes many imports, here’s a breakdown:
-- Arcade imports:
- - `Arcade`: The , used to interact with the .
- - `ToolDefinition`: The definition type, used to define the input and output of a tool.
-- CrewAI imports:
- - `BaseTool`: The base class, used to create custom CrewAI tools.
- - `Agent`: The CrewAI class, used to create an agent.
- - `EventListener`: The event listener class, used to suppress CrewAI’s rich panel output.
-- Other imports:
- - `pydantic` imports: Used for data validation and model creation when converting Arcade to LangChain tools.
- - `typing.Any`: A type hint for the any type.
- - `load_dotenv`: Loads the environment variables from the `.env` file.
- - `os`: The operating system module, used to interact with the operating system.
+- Arcade imports:
+ - `Arcade`: The , used to interact with the .
+ - `ToolDefinition`: The definition type, used to define the input and output of a tool.
+- CrewAI imports:
+ - `BaseTool`: The base class, used to create custom CrewAI tools.
+ - `Agent`: The CrewAI class, used to create an agent.
+ - `EventListener`: The event listener class, used to suppress CrewAI’s rich panel output.
+- Other imports:
+ - `pydantic` imports: Used for data validation and model creation when converting Arcade to LangChain tools.
+ - `typing.Any`: A type hint for the any type.
+ - `load_dotenv`: Loads the environment variables from the `.env` file.
+ - `os`: The operating system module, used to interact with the operating system.
### Configure the agent
-The rest of the code uses these variables to customize the and manage the . Feel free to configure them to your liking. Here, the `EventListener` class is used to suppress CrewAI’s rich panel output, which is useful for debugging but verbose for an interactive session like the one you’re building.
+The rest of the code uses these variables to customize the and manage the . Feel free to configure them to your liking. Here, the `EventListener` class is used to suppress CrewAI’s rich panel output, which is useful for debugging but verbose for an interactive session like the one you’re building.
```python
# main.py
@@ -129,7 +129,7 @@ EventListener().formatter.verbose = False
### Write a utility function to transform Arcade tool definitions into Pydantic models
-In this utility function, you transform an Arcade definition into a Pydantic model. Later, you will transform these models to construct tools in the format expected by CrewAI. The `_build_args_model` function extracts the tools’ parameters, name, and description, and maps them to a Pydantic model.
+In this utility function, you transform an Arcade definition into a Pydantic model. Later, you will transform these models to construct tools in the format expected by CrewAI. The `_build_args_model` function extracts the tools’ parameters, name, and description, and maps them to a Pydantic model.
```python
# main.py
@@ -169,8 +169,8 @@ def _build_args_model(tool_def: ToolDefinition) -> type[BaseModel]:
Here, you define the `ArcadeTool` class that extends the CrewAI `BaseTool` class to add the following capability:
-- Authorize the tool with the with the `_auth_tool` helper function
-- Execute the tool with the with the `_run` method
+- Authorize the tool with the with the `_auth_tool` helper function
+- Execute the tool with the with the `_run` method
This class captures the authorization flow outside of the agent’s , which is a good practice for security and context engineering. By handling everything in the `ArcadeTool` class, you remove the risk of the LLM replacing the authorization URL or leaking it, and you keep the context free from any authorization-related traces, which reduces the risk of hallucinations, and reduces context bloat.
@@ -220,13 +220,13 @@ class ArcadeTool(BaseTool):
### Retrieve Arcade tools and transform them into CrewAI tools
-Here you get the Arcade tools you want the agent to utilize, and transform them into CrewAI tools. The first step is to initialize the , and get the you want to work with.
+Here you get the Arcade tools you want the agent to utilize, and transform them into CrewAI tools. The first step is to initialize the , and get the you want to work with.
Here’s a breakdown of what it does for clarity:
-- retrieve tools from all configured servers (defined in the `MCP_SERVERS` variable)
-- retrieve individual (defined in the `TOOLS` variable)
-- transform the Arcade to CrewAI tools with the `ArcadeTool` class you defined earlier
+- retrieve tools from all configured servers (defined in the `MCP_SERVERS` variable)
+- retrieve individual (defined in the `TOOLS` variable)
+- transform the Arcade to CrewAI tools with the `ArcadeTool` class you defined earlier
```python
# main.py
@@ -271,10 +271,10 @@ def get_arcade_tools(
The main function is where you:
-- Get the Arcade tools from the configured servers
-- Create an with the Arcade
-- Initialize the conversation
-- Run the loop
+- Get the Arcade tools from the configured servers
+- Create an with the Arcade
+- Initialize the conversation
+- Run the loop
```python
# main.py
@@ -319,23 +319,23 @@ if __name__ == "__main__":
uv run main.py
```
-You should see the responding to your prompts like any model, as well as handling any calls and authorization requests. Here are some example prompts you can try:
+You should see the responding to your prompts like any model, as well as handling any calls and authorization requests. Here are some example prompts you can try:
-- “Send me an email with a random haiku about OpenAI ”
-- “Summarize my latest 3 emails”
+- “Send me an email with a random haiku about OpenAI ”
+- “Summarize my latest 3 emails”
## Tips for selecting tools
-- **Relevance**: Pick only the you need. Avoid using all tools at once.
-- **Avoid conflicts**: Be mindful of duplicate or overlapping functionality.
+- **Relevance**: Pick only the you need. Avoid using all tools at once.
+- **Avoid conflicts**: Be mindful of duplicate or overlapping functionality.
## Next steps
-Now that you have integrated Arcade tools into your CrewAI team, you can:
+Now that you have integrated Arcade tools into your CrewAI team, you can:
-- Experiment with different toolkits, such as “Math” or “Search.”
-- Customize the ’s prompts for specific tasks.
-- Customize the authorization and execution flow to meet your application’s requirements.
+- Experiment with different toolkits, such as “Math” or “Search.”
+- Customize the ’s prompts for specific tasks.
+- Customize the authorization and execution flow to meet your application’s requirements.
## Example code
@@ -524,8 +524,6 @@ if __name__ == "__main__":
```
-
-
Last updated on February 10, 2026
[Setup Arcade with your LLM (Python)](/en/get-started/agent-frameworks/setup-arcade-with-your-llm-python.md)
diff --git a/public/_markdown/en/get-started/agent-frameworks/openai-agents/setup-python.md b/public/_markdown/en/get-started/agent-frameworks/openai-agents/setup-python.md
index 57a2a0fcb..9297ff200 100644
--- a/public/_markdown/en/get-started/agent-frameworks/openai-agents/setup-python.md
+++ b/public/_markdown/en/get-started/agent-frameworks/openai-agents/setup-python.md
@@ -2,45 +2,45 @@
title: "Setup Arcade with OpenAI Agents SDK"
description: "Learn how to use Arcade tools in OpenAI Agents applications"
---
+
[Agent Frameworks](/en/get-started/agent-frameworks.md)
[OpenAI Agents](/en/get-started/agent-frameworks/openai-agents/overview.md)
Setup (Python)
# Setup Arcade with OpenAI Agents SDK
-Learn how to integrate Arcade tools using OpenAI primitives.
+Learn how to integrate Arcade tools using OpenAI primitives.
The [OpenAI Agents SDK](https://openai.github.io/openai-agents-python/) is a popular Python library for building AI . It builds on top of the OpenAI API, and provides an interface for building agents.
## Outcomes
-You will implement a CLI agent that can use Arcade tools to help the user with their requests. The handles that require authorization automatically, so don’t need to worry about it.
+You will implement a CLI agent that can use Arcade tools to help the user with their requests. The handles that require authorization automatically, so don’t need to worry about it.
### You will Learn
-- How to retrieve Arcade tools and transform them into OpenAI
-- How to build an OpenAI Agents
-- How to integrate Arcade tools into the OpenAI flow
-- How to implement “just in time” (JIT) authorization using Arcade’s client
+- How to retrieve Arcade tools and transform them into OpenAI
+- How to build an OpenAI Agents
+- How to integrate Arcade tools into the OpenAI flow
+- How to implement “just in time” (JIT) authorization using Arcade’s client
### Prerequisites
-- [Arcade account](https://app.arcade.dev/register)
-
-- [Obtain an Arcade API key](/get-started/setup/api-keys.md)
+- [Arcade account](https://app.arcade.dev/register)
-- The [`uv` package manager](https://docs.astral.sh/uv/)
+- [Obtain an Arcade API key](/get-started/setup/api-keys.md)
+- The [`uv` package manager](https://docs.astral.sh/uv/)
## The agent architecture you will build in this guide
-The OpenAI SDK provides an [Agent](https://openai.github.io/openai-agents-python/ref/agent/#agents.agent.Agent) class that implements a . It provides an interface for you to define the system prompt, the model, the , and possible sub-agents for handoffs. In this guide, you will manually keep track of the agent’s history and state, and use the `run` method to invoke the agent in an agentic loop.
+The OpenAI SDK provides an [Agent](https://openai.github.io/openai-agents-python/ref/agent/#agents.agent.Agent) class that implements a . It provides an interface for you to define the system prompt, the model, the , and possible sub-agents for handoffs. In this guide, you will manually keep track of the agent’s history and state, and use the `run` method to invoke the agent in an agentic loop.
## Integrate Arcade tools into an OpenAI Agents agent
### Create a new project
-Create a new directory for your and initialize a new virtual environment:
+Create a new directory for your and initialize a new virtual environment:
```bash
mkdir openai-agents-arcade-example
@@ -90,27 +90,27 @@ import json
This includes many imports, here’s a breakdown:
-- Arcade imports:
- - `AsyncArcade`: The , used to interact with the .
- - `ExecuteToolResponse`: The response type for the execute response.
-- OpenAI imports:
- - `Agent`: The OpenAI Agents , used to define an agent.
- - `Runner`: The OpenAI Agents runner, which runs the in an agentic loop.
- - `TResponseInputItem`: The response input item type, determines the type of message in the conversation history.
- - `RunContextWrapper`: Wraps the run , providing information such as the user ID, the tool name, tool arguments, and other contextual information different parts of the may need.
- - `FunctionTool`: OpenAI definition format.
- - `AgentsException`: The OpenAI exception, used to handle errors in the agentic loop.
-- Other imports:
- - `load_dotenv`: Loads the environment variables from the `.env` file.
- - `functools.partial`: Partially applies a function to a given set of arguments.
- - `typing.Any`: A type hint for the any type.
- - `os`: The operating system module, used to interact with the operating system.
- - `asyncio`: The asynchronous I/O module, used to interact with the asynchronous I/O.
- - `json`: The JSON module, used to interact with JSON data.
+- Arcade imports:
+ - `AsyncArcade`: The , used to interact with the .
+ - `ExecuteToolResponse`: The response type for the execute response.
+- OpenAI imports:
+ - `Agent`: The OpenAI Agents , used to define an agent.
+ - `Runner`: The OpenAI Agents runner, which runs the in an agentic loop.
+ - `TResponseInputItem`: The response input item type, determines the type of message in the conversation history.
+ - `RunContextWrapper`: Wraps the run , providing information such as the user ID, the tool name, tool arguments, and other contextual information different parts of the may need.
+ - `FunctionTool`: OpenAI definition format.
+ - `AgentsException`: The OpenAI exception, used to handle errors in the agentic loop.
+- Other imports:
+ - `load_dotenv`: Loads the environment variables from the `.env` file.
+ - `functools.partial`: Partially applies a function to a given set of arguments.
+ - `typing.Any`: A type hint for the any type.
+ - `os`: The operating system module, used to interact with the operating system.
+ - `asyncio`: The asynchronous I/O module, used to interact with the asynchronous I/O.
+ - `json`: The JSON module, used to interact with JSON data.
### Configure the agent
-These variables customize the and manage the in the rest of the code. Feel free to configure them to your liking.
+These variables customize the and manage the in the rest of the code. Feel free to configure them to your liking.
```python
# main.py
@@ -135,7 +135,7 @@ MODEL = "gpt-4o-mini"
Here, you define `ToolError` to handle errors from the Arcade . It wraps the `AgentsException` and provides an informative error message that the agentic loop can handle in case anything goes wrong.
-You also define `convert_output_to_json` to convert the output of the Arcade tools to a JSON string. This is useful because the output of the Arcade tools is not always a JSON object, and the OpenAI SDK expects a JSON string.
+You also define `convert_output_to_json` to convert the output of the Arcade tools to a JSON string. This is useful because the output of the Arcade tools is not always a JSON object, and the OpenAI SDK expects a JSON string.
```python
# main.py
@@ -165,9 +165,9 @@ def convert_output_to_json(output: Any) -> str:
### Write a helper function to authorize Arcade tools
-This helper function implements “just in time” (JIT) tool authorization using Arcade’s client. When the tries to execute a that requires authorization, the `result` object’s `status` will be `"pending"`, and you can use the `authorize` method to get an authorization URL. You then wait for the to complete the authorization and retry the tool call. If the user has already authorized the tool, the `status` will be `"completed"`, and the OAuth dance skips silently, which improves the user experience.
+This helper function implements “just in time” (JIT) tool authorization using Arcade’s client. When the tries to execute a that requires authorization, the `result` object’s `status` will be `"pending"`, and you can use the `authorize` method to get an authorization URL. You then wait for the to complete the authorization and retry the tool call. If the user has already authorized the tool, the `status` will be `"completed"`, and the OAuth dance skips silently, which improves the user experience.
-This function captures the authorization flow outside of the agent’s context, which is a good practice for security and context engineering. By handling everything in the , you remove the risk of the LLM replacing the authorization URL or leaking it, and you keep the free from any authorization-related traces, which reduces the risk of hallucinations.
+This function captures the authorization flow outside of the agent’s context, which is a good practice for security and context engineering. By handling everything in the , you remove the risk of the LLM replacing the authorization URL or leaking it, and you keep the free from any authorization-related traces, which reduces the risk of hallucinations.
```python
# main.py
@@ -188,7 +188,7 @@ async def authorize_tool(client: AsyncArcade, context: RunContextWrapper, tool_n
### Write a helper function to execute Arcade tools
-This helper function shows how the OpenAI framework invokes the Arcade tools. It handles the authorization flow, and then calls the using the `execute` method. It handles the conversion of the arguments from JSON to a dictionary (expected by Arcade) and the conversion of the output from the Arcade tool to a JSON string (expected by the OpenAI Agents framework). Here is where you call the helper functions defined earlier to authorize the tool and convert the output to a JSON string.
+This helper function shows how the OpenAI framework invokes the Arcade tools. It handles the authorization flow, and then calls the using the `execute` method. It handles the conversion of the arguments from JSON to a dictionary (expected by Arcade) and the conversion of the output from the Arcade tool to a JSON string (expected by the OpenAI Agents framework). Here is where you call the helper functions defined earlier to authorize the tool and convert the output to a JSON string.
```python
# main.py
@@ -217,14 +217,14 @@ async def invoke_arcade_tool(
### Retrieve Arcade tools and transform them into LangChain tools
-Here you get the Arcade tools you want the agent to use, and transform them into OpenAI Agents tools. The first step is to initialize the , and get the tools you want. Since OpenAI is itself an inference provider, the provides a convenient endpoint to get the tools in the OpenAI format, which is also the format expected by the OpenAI framework.
+Here you get the Arcade tools you want the agent to use, and transform them into OpenAI Agents tools. The first step is to initialize the , and get the tools you want. Since OpenAI is itself an inference provider, the provides a convenient endpoint to get the tools in the OpenAI format, which is also the format expected by the OpenAI framework.
This helper function is long, here’s a breakdown of what it does for clarity:
-- retrieve tools from all configured servers (defined in the `MCP_SERVERS` variable)
-- retrieve individual (defined in the `TOOLS` variable)
-- get the Arcade to OpenAI-formatted tools
-- create a list of FunctionTool objects, mapping each tool to a partial function that invokes the tool via the .
+- retrieve tools from all configured servers (defined in the `MCP_SERVERS` variable)
+- retrieve individual (defined in the `TOOLS` variable)
+- get the Arcade to OpenAI-formatted tools
+- create a list of FunctionTool objects, mapping each tool to a partial function that invokes the tool via the .
```python
# main.py
@@ -294,14 +294,14 @@ async def get_arcade_tools(
The main function is where you:
-- Get the tools from the configured servers
-- Create an with the configured
-- Initialize the conversation
-- Run the loop
+- Get the tools from the configured servers
+- Create an with the configured
+- Initialize the conversation
+- Run the loop
The loop is a while loop that captures the user input, appends it to the conversation history, and then runs the . The agent’s response is then appended to the conversation history, and the loop continues.
-When a interrupts the loop, the interruption handles via the helper function you wrote earlier.
+When a interrupts the loop, the interruption handles via the helper function you wrote earlier.
```python
# main.py
@@ -350,20 +350,20 @@ if __name__ == "__main__":
uv run main.py
```
-You should see the responding to your prompts like any model, as well as handling any calls and authorization requests. Here are some example prompts you can try:
+You should see the responding to your prompts like any model, as well as handling any calls and authorization requests. Here are some example prompts you can try:
-- “Send me an email with a random haiku about OpenAI ”
-- “Summarize my latest 3 emails”
+- “Send me an email with a random haiku about OpenAI ”
+- “Summarize my latest 3 emails”
## Key takeaways
-- You can integrate Arcade tools into any agentic framework like OpenAI , all you need is to transform the Arcade into OpenAI Agents tools and handle the authorization flow.
-- isolation: By handling the authorization flow outside of the ’s context, you remove the risk of the LLM replacing the authorization URL or leaking it, and you keep the context free from any authorization-related traces, which reduces the risk of hallucinations.
+- You can integrate Arcade tools into any agentic framework like OpenAI , all you need is to transform the Arcade into OpenAI Agents tools and handle the authorization flow.
+- isolation: By handling the authorization flow outside of the ’s context, you remove the risk of the LLM replacing the authorization URL or leaking it, and you keep the context free from any authorization-related traces, which reduces the risk of hallucinations.
## Next steps
-1. Try adding additional tools to the or modifying the in the catalog for a different use case by modifying the `MCP_SERVERS` and `TOOLS` variables.
-2. Try implementing a fully deterministic flow before the agentic loop, you can use this deterministic phase to prepare the for the , adding things like the current date, time, or any other information that is relevant to the task at hand.
+1. Try adding additional tools to the or modifying the in the catalog for a different use case by modifying the `MCP_SERVERS` and `TOOLS` variables.
+2. Try implementing a fully deterministic flow before the agentic loop, you can use this deterministic phase to prepare the for the , adding things like the current date, time, or any other information that is relevant to the task at hand.
## Example code
diff --git a/public/_markdown/en/get-started/agent-frameworks/openai-agents/use-arcade-with-openai-agents.md b/public/_markdown/en/get-started/agent-frameworks/openai-agents/use-arcade-with-openai-agents.md
new file mode 100644
index 000000000..2f0665d92
--- /dev/null
+++ b/public/_markdown/en/get-started/agent-frameworks/openai-agents/use-arcade-with-openai-agents.md
@@ -0,0 +1,36 @@
+---
+title: "Arcade with OpenAI Agents"
+description: "Integrate Arcade tools with the OpenAI Agents SDK"
+---
+[Agent Frameworks](/en/get-started/agent-frameworks.md)
+OpenAI AgentsOverview
+
+# Arcade with OpenAI Agents
+
+The [OpenAI Agents SDK](https://openai.github.io/openai-agents-python/) provides a framework for building AI . Arcade integrates with both the Python and JavaScript versions, giving your agents access to Gmail, GitHub, Slack, and 100+ other .
+
+## Get started
+
+Choose your language to set up Arcade with OpenAI :
+
+- **[Python setup](/get-started/agent-frameworks/openai-agents/setup-python.md)
+ ** - Build a CLI with Arcade using the `agents-arcade` package
+- **[TypeScript setup](/get-started/agent-frameworks/openai-agents/setup-typescript.md)
+ ** - Build an with Arcade using `@arcadeai/arcadejs`
+
+## What you can build
+
+With Arcade and OpenAI , your agents can:
+
+- Read and send emails via Gmail
+- Post messages to Slack channels
+- Create GitHub issues and pull requests
+- Search the web and extract content
+- Access 100+ other integrations
+
+Browse the [full MCP server catalog](/resources/integrations.md) to see all available .
+
+Last updated on February 10, 2026
+
+[Mastra](/en/get-started/agent-frameworks/mastra.md)
+[Setup (Python)](/en/get-started/agent-frameworks/openai-agents/setup-python.md)
diff --git a/public/_markdown/en/get-started/mcp-clients/github-copilot.md b/public/_markdown/en/get-started/mcp-clients/github-copilot.md
new file mode 100644
index 000000000..91ff5783c
--- /dev/null
+++ b/public/_markdown/en/get-started/mcp-clients/github-copilot.md
@@ -0,0 +1,135 @@
+---
+title: "Use Arcade in GitHub Copilot"
+description: "Arcade - AI platform for developers"
+---
+[MCP Clients](/en/get-started/mcp-clients.md)
+GitHub Copilot
+
+# Use Arcade in GitHub Copilot
+
+## Outcomes
+
+Connect GitHub Copilot to an Arcade Gateway.
+
+### Prerequisites
+
+1. Create an [Arcade](https://app.arcade.dev/register)
+
+2. Get an [Arcade API key](/get-started/setup/api-keys.md)
+
+3. Create an [Arcade MCP Gateway](/guides/mcp-gateways.md)
+ and select the you want to use
+
+### Set up GitHub Copilot
+
+### VS Code
+
+In VS Code, Github Copilot will automatically detect the configured servers. Read the [VS Code instructions](/get-started/mcp-clients/visual-studio-code.md) to set both of them up.
+
+### JetBrains IDEs
+
+The GitHub Copilot extension for JetBrains IDEs does not currently support remote servers with Dynamic Client Registration. To use an Arcade with GitHub Copilot on a JetBrains IDE, you must configure the MCP gateway as `Arcade Headers` in the dashboard.
+
+1. In the lower right corner, click the GitHub Copilot icon.
+2. From the menu, select “Open Chat”, make sure you are in mode, then click the icon.
+3. A dialog will open with a list of . On the bottom left, click ”+ Add More Tools…”
+4. This will open the `mcp.json` file in the editor. In the `mcp.json` file, define your servers.
+
+### Arcade Headers
+
+```json
+{
+ "servers": {
+ "mcp-arcade": {
+ "url": "https://api.arcade.dev/mcp/",
+ "requestInit": {
+ "headers": {
+ "Authorization": "Bearer {arcade_api_key}",
+ "Arcade-User-ID": "{arcade_user_id}"
+ }
+ }
+ }
+ }
+}
+```
+
+### Arcade Auth
+
+The GitHub Copilot extension for JetBrains IDEs does not currently support remote servers with Dynamic Client Registration. To use an Arcade with GitHub Copilot on a JetBrains IDE, you must configure the MCP gateway as `Arcade Auth` in the dashboard.
+
+Once you save the `mcp.json` file, a start button will appear over the new server name. Click it to start the server.
+
+
+
+ tools are only available in mode.
+
+### Visual Studio
+
+The GitHub Copilot extension for Visual Studio does not currently support every remote server with Dynamic Client Registration. To use an Arcade with GitHub Copilot on Visual Studio, you must configure the MCP gateway as `Arcade Headers` in the dashboard.
+
+In Visual Studio,
+
+1. In the upper right corner, click the GitHub Copilot icon.
+
+ 
+2. On the bottom of the GitHub Copilot panel, click the icon (two wrenches).
+
+ 
+3. A dialog will open with a list of tools. On the top right corner of this dialog, click the ”+” icon to add a new .
+
+ 
+4. This will open another dialog. Fill in the information for your server. You will need to choose:
+
+ - **Destination**: The path to the configuration file, if you choose “Global”, the will be added to all solutions. If you choose “Solution”, the MCP gateway will be added to the current solution only.
+ - **Server ID**: The ID of the server you’re adding, this is how it will be displayed in the list of servers.
+ - **Type**: For gateways, you must select “HTTP”.
+ - **URL**: The URL of the gateway.
+ - **Headers**: The headers to pass to the gateway.
+ - Click “Save” to add the server.
+
+ 
+5. Once you save the server, it will be added to the list of servers. It will be disabled by default. To enable it, click the checkbox next to the server name.
+
+ 
+6. Once the server is enabled, it will be available in the list of . If tools are not available, you may need to open the `.mcp.json` file you picked as the destination. Visual Studio will display a “Configure” and “Reconnect” buttons on top of each entry. Clicking “Reconnect” should fix any issues.
+
+ 
+
+### Arcade Headers
+
+```json
+{
+ "servers": {
+ "mcp-arcade": {
+ "url": "https://api.arcade.dev/mcp/",
+ "headers": {
+ "Authorization": "Bearer {arcade_api_key}",
+ "Arcade-User-ID": "{arcade_user_id}"
+ }
+ }
+ }
+}
+```
+
+### Arcade Auth
+
+The GitHub Copilot extension for Visual Studio does not currently support every remote server with Dynamic Client Registration. To use an Arcade with GitHub Copilot on Visual Studio, you must configure the MCP gateway as `Arcade Headers` in the dashboard.
+
+### Eclipse
+
+Coming soon…
+
+### XCode
+
+Coming soon…
+
+### Try it out
+
+1. Open the chat pane (typically command-l)
+2. Make sure you are in mode
+3. Ask the to use a .
+
+Last updated on February 10, 2026
+
+[Microsoft Copilot Studio](/en/get-started/mcp-clients/copilot-studio.md)
+[Overview](/en/resources/integrations.md)
diff --git a/public/_markdown/en/references/mcp/python.md b/public/_markdown/en/references/mcp/python.md
index c2e6c7b14..a6d928e03 100644
--- a/public/_markdown/en/references/mcp/python.md
+++ b/public/_markdown/en/references/mcp/python.md
@@ -2,11 +2,12 @@
title: "Arcade MCP Server - Python overview"
description: "Overview of the arcade-mcp-server Python package and the MCPApp class"
---
+
Arcade MCPOverview
# Arcade MCP Server - Python overview
-`arcade-mcp-server` is Arcade’s framework for building servers. It provides a clean, minimal API to build programmatically. The main entry point is `MCPApp`, which handles collection, server configuration, and transport setup.
+`arcade-mcp-server` is Arcade’s framework for building servers. It provides a clean, minimal API to build programmatically. The main entry point is `MCPApp`, which handles collection, server configuration, and transport setup.
## Quick start
@@ -30,7 +31,7 @@ if __name__ == "__main__":
**`arcade_mcp_server.mcp_app.MCPApp`**
-A FastAPI-like interface for building servers. The app collects and configuration, then lazily creates the server and transport when `run()` is called.
+A FastAPI-like interface for building servers. The app collects and configuration, then lazily creates the server and transport when `run()` is called.
### `__init__`
@@ -50,7 +51,7 @@ MCPApp(
)
```
-Initialize the app.
+Initialize the app.
**Parameters:**
@@ -154,9 +155,9 @@ Additional server configuration passed to the underlying `MCPServer`
#### `tools`
-Runtime and build-time API. Returns a `_ToolsAPI` object with async methods: `add()`, `update()`, `remove()`, `list()`.
+Runtime and build-time API. Returns a `_ToolsAPI` object with async methods: `add()`, `update()`, `remove()`, `list()`.
-The runtime API (`app.tools.add()`, etc.) requires a server to be bound via `app.server`. It is only available after the server has started. Use the `@app.tool` decorator or `app.add_tool()` for build-time tool registration.
+The runtime API (`app.tools.add()`, etc.) requires a server to be bound via `app.server`. It is only available after the server has started. Use the `@app.tool` decorator or `app.add_tool()` for build-time tool registration.
#### `prompts`
@@ -271,7 +272,7 @@ app.add_tool(
)
```
-Add a for build-time materialization (before the server starts). Accepts the same parameters as the `@app.tool` decorator.
+Add a for build-time materialization (before the server starts). Accepts the same parameters as the `@app.tool` decorator.
#### `add_tools_from_module`
@@ -318,7 +319,7 @@ app.run(
)
```
-Start the server. This method blocks until the server shuts down. It exits with an error if no have been registered.
+Start the server. This method blocks until the server shuts down. It exits with an error if no have been registered.
**Parameters:**
@@ -374,15 +375,15 @@ The `run()` method checks for environment variable overrides before starting. Se
## Transport modes
- servers communicate with clients through different transport mechanisms. Select a transport by passing the `transport` argument to `run()`.
+servers communicate with clients through different transport mechanisms. Select a transport by passing the `transport` argument to `run()`.
### stdio
The stdio transport communicates over standard input/output streams. It is the default transport, used by Claude Desktop and similar clients.
-- Logs go to stderr to avoid interfering with JSON-RPC messages on stdout
-- Single-session only
-- No network exposure
+- Logs go to stderr to avoid interfering with JSON-RPC messages on stdout
+- Single-session only
+- No network exposure
```python
app.run(transport="stdio")
@@ -390,11 +391,11 @@ app.run(transport="stdio")
### HTTP (Streamable HTTP)
-The HTTP transport runs a FastAPI/Uvicorn server with Streamable HTTP and Server-Sent Events (SSE) support. The server mounts it at the `/mcp` endpoint.
+The HTTP transport runs a FastAPI/Uvicorn server with Streamable HTTP and Server-Sent Events (SSE) support. The server mounts it at the `/mcp` endpoint.
-- Supports multiple concurrent sessions
-- JSON-RPC over HTTP POST, SSE streaming over HTTP GET
-- Optional front-door authentication via the `auth` parameter
+- Supports multiple concurrent sessions
+- JSON-RPC over HTTP POST, SSE streaming over HTTP GET
+- Optional front-door authentication via the `auth` parameter
```python
app.run(transport="http", host="0.0.0.0", port=8000)
diff --git a/public/_markdown/en/references/mcp/python/server.md b/public/_markdown/en/references/mcp/python/server.md
index a7753ad2e..ed09e6752 100644
--- a/public/_markdown/en/references/mcp/python/server.md
+++ b/public/_markdown/en/references/mcp/python/server.md
@@ -2,28 +2,29 @@
title: "Server"
description: "Reference documentation for the low-level MCPServer class"
---
+
Arcade MCP[Python](/en/references/mcp/python.md)
Server
# Server
-Most should use [`MCPApp`](/references/mcp/python.md) instead of `MCPServer` directly. `MCPServer` is a low-level API for advanced use cases.
+Most should use [`MCPApp`](/references/mcp/python.md) instead of `MCPServer` directly. `MCPServer` is a low-level API for advanced use cases.
-The `MCPServer` class is the core server implementation that handles protocol messages, middleware orchestration, and component management for , resources, and prompts.
+The `MCPServer` class is the core server implementation that handles protocol messages, middleware orchestration, and component management for , resources, and prompts.
## `MCPServer`
**`arcade_mcp_server.server.MCPServer`**
- Server with middleware and support.
+Server with middleware and support.
This server provides:
-- Middleware chain for extensible request processing
-- injection for
-- Component managers for , resources, and prompts
-- Bidirectional communication with clients
-- Authorization and secret management for execution
+- Middleware chain for extensible request processing
+- injection for
+- Component managers for , resources, and prompts
+- Bidirectional communication with clients
+- Authorization and secret management for execution
### `__init__`
@@ -44,7 +45,7 @@ MCPServer(
)
```
-Initialize the server.
+Initialize the server.
**Parameters:**
@@ -150,7 +151,7 @@ The server automatically adds `ErrorHandlingMiddleware` and (if enabled in setti
#### `tools`
-Access the `ToolManager` for runtime operations: `add_tool()`, `update_tool()`, `remove_tool()`, `list_tools()`, `get_tool()`.
+Access the `ToolManager` for runtime operations: `add_tool()`, `update_tool()`, `remove_tool()`, `list_tools()`, `get_tool()`.
#### `resources`
@@ -168,7 +169,7 @@ Access the `PromptManager` for runtime prompt operations: `add_prompt()`, `remov
async server.start()
```
-Start the server and all component managers. Loads from the initial catalog, starts the lifespan manager, and checks for missing secrets. Safe to call multiple times (subsequent calls are no-ops).
+Start the server and all component managers. Loads from the initial catalog, starts the lifespan manager, and checks for missing secrets. Safe to call multiple times (subsequent calls are no-ops).
#### `stop`
@@ -184,7 +185,7 @@ Stop the server and all component managers. Shuts down the lifespan manager and
async server.run_connection(read_stream, write_stream, init_options=None)
```
-Run a single connection. Creates a `ServerSession`, registers it, and processes messages until the connection ends.
+Run a single connection. Creates a `ServerSession`, registers it, and processes messages until the connection ends.
**Parameters:**
@@ -226,7 +227,7 @@ Connection initialization options (for example, `{"transport_type": "stdio"}`)
async server.handle_message(message, session=None, resource_owner=None)
```
-Handle an incoming message. Validates the message, applies middleware, dispatches to the appropriate handler, and returns a response.
+Handle an incoming message. Validates the message, applies middleware, dispatches to the appropriate handler, and returns a response.
**Parameters:**
@@ -274,7 +275,7 @@ JSON-RPC response, error, or `None` for notifications
### Supported MCP methods
-The server handles the following protocol methods:
+The server handles the following protocol methods:
Method
diff --git a/public/_markdown/en/references/mcp/python/settings.md b/public/_markdown/en/references/mcp/python/settings.md
index 59bf4ff66..4c929f45b 100644
--- a/public/_markdown/en/references/mcp/python/settings.md
+++ b/public/_markdown/en/references/mcp/python/settings.md
@@ -2,12 +2,13 @@
title: "Settings"
description: "Configuration and environment-driven settings for the Arcade MCP Server"
---
+
Arcade MCP[Python](/en/references/mcp/python.md)
Settings
# Settings
-`MCPSettings` is the main configuration container for the Arcade Server. All settings classes use [Pydantic Settings](https://docs.pydantic.dev/latest/concepts/pydantic_settings/) with environment variable support.
+`MCPSettings` is the main configuration container for the Arcade Server. All settings classes use [Pydantic Settings](https://docs.pydantic.dev/latest/concepts/pydantic_settings/) with environment variable support.
## `MCPSettings`
@@ -107,7 +108,7 @@ Create settings from environment variables. Automatically loads a `.env` file fr
settings.tool_secrets()
```
-Returns a `dict[str, Any]` of secrets collected from the environment.
+Returns a `dict[str, Any]` of secrets collected from the environment.
#### `to_dict`
@@ -141,7 +142,7 @@ settings = MCPSettings(
)
```
-* * *
+---
## Sub-settings
@@ -439,7 +440,7 @@ JSON array of authorization server configurations. Each entry must have `authori
**Bases:** `BaseSettings`
-Collects environment variables as secrets. Every environment variable that is **not** prefixed with `MCP_` or `_` is added to the tool environment and made available as a tool secret in the `ToolContext`.
+Collects environment variables as secrets. Every environment variable that is **not** prefixed with `MCP_` or `_` is added to the tool environment and made available as a tool secret in the `ToolContext`.
Also loads variables from a `.env` file in the current working directory.
@@ -459,7 +460,7 @@ Collected tool secrets from environment
`{}` (auto-populated)
-* * *
+---
## Environment variable reference
diff --git a/public/_markdown/en/references/mcp/python/transports.md b/public/_markdown/en/references/mcp/python/transports.md
new file mode 100644
index 000000000..b822ac08d
--- /dev/null
+++ b/public/_markdown/en/references/mcp/python/transports.md
@@ -0,0 +1,233 @@
+---
+title: "Transport Modes"
+description: "Learn about stdio and HTTP transport modes for MCP servers"
+---
+Arcade MCP[Python](/en/references/mcp/python.md)
+Transports
+
+# Transport Modes
+
+ servers can communicate with clients through different transport mechanisms. Each transport is optimized for specific use cases and client types.
+
+The stdio transport is the default transport for servers. It is used by Claude Desktop and similar clients to run locally. Learn more about the different [server types](/guides/create-tools/tool-basics/compare-server-types.md).
+
+## stdio Transport
+
+The stdio (standard input/output) transport is used for direct client connections.
+
+### Characteristics
+
+- Communicates via standard input/output streams
+- Logs go to stderr to avoid interfering with protocol messages
+- Ideal for desktop applications and command-line
+- Used by Claude Desktop and similar clients
+
+### Usage
+
+**Recommended: Using Arcade CLI**
+
+```bash
+# Run with stdio transport
+uv run server.py stdio
+```
+
+**Alternative: Direct Python**
+
+```python
+# Run your server directly
+uv run server.py stdio
+
+# Or with python
+app.run(transport="stdio")
+```
+
+### Client Configuration
+
+For Claude Desktop, use the `arcade configure` command:
+
+```bash
+arcade configure claude --host local
+```
+
+Or manually edit `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+ "mcpServers": {
+ "my-tools": {
+ "command": "arcade",
+ "args": ["mcp", "stdio"],
+ "cwd": "/path/to/your/tools"
+ }
+ }
+}
+```
+
+## HTTP Transport
+
+The HTTP transport provides REST/SSE endpoints for web-based clients.
+
+### Characteristics
+
+- RESTful API with Server-Sent Events (SSE) for streaming
+- Supports hot reload for development
+- Includes health checks and API documentation
+- Can be deployed behind reverse proxies
+- Suitable for web applications and services
+
+### Usage
+
+**Recommended: Using Arcade CLI**
+
+```bash
+# Run with HTTP transport (default)
+uv run server.py
+uv run server.py http
+```
+
+**Alternative: Direct Python**
+
+```python
+# Run your server directly
+uv run server.py
+
+# Or with python
+app.run(transport="http", host="0.0.0.0", port=8080)
+```
+
+### Endpoints
+
+When running in HTTP mode, the server provides:
+
+- `GET /worker/health` - Health check endpoint
+- `GET /mcp` - SSE endpoint for protocol
+- `GET /docs` - Swagger UI documentation (debug mode)
+- `GET /redoc` - ReDoc documentation (debug mode)
+
+### Development Features
+
+**With Arcade CLI:**
+
+```python
+# Enable hot reload and debug mode
+app.run(host="127.0.0.1", port=8000, reload=True)
+
+# This enables:
+# - Automatic restart on code changes
+# - Detailed error messages
+# - API documentation endpoints
+# - Verbose logging
+```
+
+## Choosing a Transport
+
+### Use stdio when:
+
+- Integrating with desktop applications (Claude Desktop, VS Code)
+- Building command-line
+- You need simple, direct communication
+- Running in environments without network access
+
+### Use HTTP when:
+
+- Building web applications
+- Deploying to cloud environments
+- You need to support multiple concurrent clients
+- Integrating with existing web services
+- You want API documentation and testing
+
+## Transport Configuration
+
+### Environment Variables
+
+Both transports respect common environment variables:
+
+```bash
+# Server identification
+MCP_SERVER_NAME="My MCP Server"
+MCP_SERVER_VERSION="1.0.0"
+
+# Logging
+MCP_DEBUG=true
+MCP_LOG_LEVEL=DEBUG
+
+# HTTP-specific
+MCP_HTTP_HOST=0.0.0.0
+MCP_HTTP_PORT=8080
+```
+
+### Programmatic Configuration
+
+When using MCPApp:
+
+```python
+from arcade_mcp_server import MCPApp
+
+app = MCPApp(
+ name="my-server",
+ version="1.0.0",
+ log_level="DEBUG"
+)
+
+# Run with specific transport
+if __name__ == "__main__":
+ import sys
+
+ if len(sys.argv) > 1 and sys.argv[1] == "stdio":
+ app.run(transport="stdio")
+ else:
+ app.run(transport="http", host="0.0.0.0", port=8080)
+```
+
+## Security Considerations
+
+### stdio Transport
+
+- Inherits security of the parent process
+- No network exposure
+- Suitable for trusted environments
+
+### HTTP Transport
+
+- Exposes network endpoints
+- Should use authentication in production
+- Consider using HTTPS with reverse proxy
+- Implement rate limiting for public deployments
+
+## Advanced Transport Features
+
+### Custom Middleware (HTTP)
+
+Add custom middleware to HTTP transports:
+
+```python
+from arcade_mcp_server import MCPApp
+
+app = MCPApp(name="my-server")
+
+# Add custom middleware
+@app.middleware("http")
+async def add_custom_headers(request, call_next):
+ response = await call_next(request)
+ response.headers["X-Custom-Header"] = "value"
+ return response
+```
+
+### Transport Events
+
+Listen to transport lifecycle events:
+
+```python
+@app.on_event("startup")
+async def startup_handler():
+ print("Server starting up...")
+
+@app.on_event("shutdown")
+async def shutdown_handler():
+ print("Server shutting down...")
+```
+
+Last updated on February 10, 2026
+
+[Overview](/en/references/mcp/python.md)
+[Server](/en/references/mcp/python/server.md)
diff --git a/public/_markdown/en/references/mcp/python/types.md b/public/_markdown/en/references/mcp/python/types.md
new file mode 100644
index 000000000..61405e65a
--- /dev/null
+++ b/public/_markdown/en/references/mcp/python/types.md
@@ -0,0 +1,67 @@
+---
+title: "Types"
+description: "Arcade - AI platform for developers"
+---
+Arcade MCP[Python](/en/references/mcp/python.md)
+Types
+
+# Types
+
+Core Pydantic models and enums for the protocol shapes.
+
+## `arcade_mcp_server.types`
+
+### `CallToolResult`
+
+**Bases:** `Result`
+
+A list of content objects that represent the unstructured result of the call.
+
+#### `content` (instance-attribute)
+
+An optional JSON object that represents the structured result of the call.
+
+### `SessionMessage`
+
+**Type:** dataclass
+
+Wrapper for messages in transport sessions.
+
+## Examples
+
+### Constructing a JSON-RPC request and response model
+
+```python
+from arcade_mcp_server.types import JSONRPCRequest, JSONRPCResponse
+
+req = JSONRPCRequest(id=1, method="ping", params={})
+res = JSONRPCResponse(id=req.id, result={})
+print(req.model_dump_json())
+print(res.model_dump_json())
+```
+
+### Building a tools/call request and examining result shape
+
+```python
+from arcade_mcp_server.types import CallToolRequest, CallToolResult, TextContent
+
+call = CallToolRequest(
+ id=2,
+ method="tools/call",
+ params={
+ "name": "Toolkit.tool",
+ "arguments": {"text": "hello"},
+ },
+)
+# Result would typically be produced by the server:
+result = CallToolResult(
+ content=[TextContent(type="text", text="Echo: hello")],
+ structuredContent={"result": "Echo: hello"},
+ isError=False
+)
+```
+
+Last updated on February 10, 2026
+
+[Middleware](/en/references/mcp/python/middleware.md)
+[Errors](/en/references/mcp/python/errors.md)
diff --git a/public/images/mcp-gateway/github-copilot/jetbrains/start-mcp.png b/public/images/mcp-gateway/github-copilot/jetbrains/start-mcp.png
new file mode 100644
index 000000000..8be2b0d54
Binary files /dev/null and b/public/images/mcp-gateway/github-copilot/jetbrains/start-mcp.png differ
diff --git a/public/images/mcp-gateway/github-copilot/visual-studio/step-1.png b/public/images/mcp-gateway/github-copilot/visual-studio/step-1.png
new file mode 100644
index 000000000..8ac05beb2
Binary files /dev/null and b/public/images/mcp-gateway/github-copilot/visual-studio/step-1.png differ
diff --git a/public/images/mcp-gateway/github-copilot/visual-studio/step-2.png b/public/images/mcp-gateway/github-copilot/visual-studio/step-2.png
new file mode 100644
index 000000000..0651c155c
Binary files /dev/null and b/public/images/mcp-gateway/github-copilot/visual-studio/step-2.png differ
diff --git a/public/images/mcp-gateway/github-copilot/visual-studio/step-3.png b/public/images/mcp-gateway/github-copilot/visual-studio/step-3.png
new file mode 100644
index 000000000..9834e6e18
Binary files /dev/null and b/public/images/mcp-gateway/github-copilot/visual-studio/step-3.png differ
diff --git a/public/images/mcp-gateway/github-copilot/visual-studio/step-4.png b/public/images/mcp-gateway/github-copilot/visual-studio/step-4.png
new file mode 100644
index 000000000..9d5cfe4fd
Binary files /dev/null and b/public/images/mcp-gateway/github-copilot/visual-studio/step-4.png differ
diff --git a/public/images/mcp-gateway/github-copilot/visual-studio/step-5.png b/public/images/mcp-gateway/github-copilot/visual-studio/step-5.png
new file mode 100644
index 000000000..41081746a
Binary files /dev/null and b/public/images/mcp-gateway/github-copilot/visual-studio/step-5.png differ
diff --git a/public/images/mcp-gateway/github-copilot/visual-studio/step-6.png b/public/images/mcp-gateway/github-copilot/visual-studio/step-6.png
new file mode 100644
index 000000000..62811eea7
Binary files /dev/null and b/public/images/mcp-gateway/github-copilot/visual-studio/step-6.png differ
diff --git a/public/llms.txt b/public/llms.txt
index 0aeb4c4ba..3b8e0a809 100644
--- a/public/llms.txt
+++ b/public/llms.txt
@@ -1,4 +1,4 @@
-
+
# Arcade
@@ -54,7 +54,9 @@ Arcade delivers three core capabilities: Deploy agents even your security team w
- [Telemetry](https://docs.arcade.dev/en/references/mcp/telemetry.md): This documentation page provides an overview of the telemetry data collected by the `arcade-mcp` framework, detailing what information is tracked, the purpose of data collection, and how users can opt-out if they choose. It emphasizes the importance of telemetry in
- [The Arcade CLI](https://docs.arcade.dev/en/references/arcade-cli.md): The Arcade CLI documentation provides users with instructions on how to install and utilize the Arcade command-line tool for managing Arcade deployments, generating and testing MCP servers, and performing various related tasks. It includes detailed installation commands and usage guidelines for different commands available within the
- [TickTick](https://docs.arcade.dev/en/references/auth-providers/ticktick.md): This documentation page provides guidance on configuring the TickTick authentication provider to enable tools and agents to access TickTick APIs using OAuth 2.0. It outlines the steps for creating a TickTick app, setting up OAuth settings, and integrating the authentication provider
+- [Transport Modes](https://docs.arcade.dev/en/references/mcp/python/transports.md): This documentation page provides an overview of the different transport modes (stdio and HTTP) available for MCP servers, detailing their characteristics, usage scenarios, and configuration options. Users will learn when to utilize each transport mode based on their application needs, whether for desktop
- [Twitch](https://docs.arcade.dev/en/references/auth-providers/twitch.md): This documentation page provides guidance on configuring a custom Twitch authentication provider within the Arcade platform, allowing users to access the Twitch API on behalf of their users. It outlines the necessary steps to create a Twitch app, set up OAuth credentials, and integrate the authentication
+- [Types](https://docs.arcade.dev/en/references/mcp/python/types.md): This documentation page provides an overview of core Pydantic models and enums used in the Arcade AI platform, specifically focusing on the `arcade_mcp_server.types` module. Users will learn about key data structures like `CallToolResult` and `
- [X](https://docs.arcade.dev/en/references/auth-providers/x.md): This documentation page provides guidance on using and configuring the X auth provider to enable applications and agents to interact with the X (Twitter) API on behalf of users. It outlines the steps for creating an X app, configuring authentication within the Arcade platform, and
- [Zendesk](https://docs.arcade.dev/en/references/auth-providers/zendesk.md): This documentation page provides guidance on configuring Zendesk authentication within the Arcade platform, enabling users to call Zendesk APIs on behalf of a user. It outlines the steps to create a custom Zendesk auth provider, set up a Zendesk app, and manage
- [Zoho](https://docs.arcade.dev/en/references/auth-providers/zoho.md): This documentation page provides guidance on using the Zoho auth provider to enable applications and agents to access Zoho APIs through OAuth 2.0 authentication. It includes instructions for configuring Zoho app credentials, creating a Zoho app, and integrating with pre
@@ -79,6 +81,7 @@ Arcade delivers three core capabilities: Deploy agents even your security team w
- [Arcade with Google ADK](https://docs.arcade.dev/en/get-started/agent-frameworks/google-adk/overview.md): This documentation page provides a comprehensive guide for integrating the `google-adk-arcade` package with the Google ADK library, enabling users to enhance their AI agents with various Arcade tools such as Google Mail and GitHub. It covers installation, key
- [Arcade with LangChain](https://docs.arcade.dev/en/get-started/agent-frameworks/langchain/overview.md): The "Arcade with LangChain" documentation page provides users with guidance on integrating Arcade tools with LangChain agents, enabling them to leverage various services like Gmail, GitHub, and Slack. It offers setup instructions for both Python and TypeScript, along
- [Arcade with OpenAI Agents](https://docs.arcade.dev/en/get-started/agent-frameworks/openai-agents/overview.md): This documentation page provides a comprehensive guide for integrating Arcade with the OpenAI Agents library, enabling users to enhance their AI agents with various tools like Gmail, LinkedIn, and GitHub. It covers installation, key features, basic usage examples, and handling
+- [Arcade with OpenAI Agents](https://docs.arcade.dev/en/get-started/agent-frameworks/openai-agents/use-arcade-with-openai-agents.md): This documentation page provides guidance on integrating Arcade tools with the OpenAI Agents SDK, enabling users to build AI agents that can interact with various applications like Gmail, GitHub, and Slack. It offers setup instructions for both Python and TypeScript, along with
- [ArcadeEngineApi](https://docs.arcade.dev/en/resources/integrations/development/arcade-engine-api.md): The ArcadeEngineApi documentation provides users with a comprehensive guide to the tools available for interacting with the Arcade Engine API, focusing on managing authentication providers, secrets, and worker configurations. It outlines various actions users and LLMs can perform, such as retrieving
- [Asana](https://docs.arcade.dev/en/resources/integrations/productivity/asana.md): This documentation page provides users with a comprehensive guide to the Arcade Asana MCP Server, enabling them to build agents and AI applications that interact with Asana tasks, projects, and workspaces. Users can learn how to manage teams, create and update tasks
- [Asana Reference](https://docs.arcade.dev/en/resources/integrations/productivity/asana/reference.md): The Asana Reference documentation provides a comprehensive list of enumerations related to tag colors, task sorting options, and sort orders used in the Asana MCP Server. Users can utilize this reference to understand and implement the various color codes and sorting parameters effectively in
@@ -206,6 +209,7 @@ Arcade delivers three core capabilities: Deploy agents even your security team w
- [PagerdutyApi](https://docs.arcade.dev/en/resources/integrations/development/pagerduty-api.md): The PagerDutyApi documentation provides a comprehensive overview of tools that enable users to manage incidents, services, and integrations within the PagerDuty platform using the API. It outlines various functionalities, such as assigning tags, retrieving metrics, and managing add-ons, allowing
- [Postgres](https://docs.arcade.dev/en/resources/integrations/databases/postgres.md): This documentation page provides users with a comprehensive guide to the Arcade Postgres MCP Server, which enables agents to interact with PostgreSQL databases in a read-only manner. Users can learn how to discover database schemas, explore table structures, and execute safe SELECT queries
- [PosthogApi](https://docs.arcade.dev/en/resources/integrations/development/posthog-api.md): The PosthogApi documentation provides users with tools and guidance for managing and analyzing data within the PostHog platform via its API. It details the necessary configuration, including authentication secrets, and outlines various available tools for retrieving metrics, managing exports, and handling
+- [Provide the tool manager callback to the ArcadeToolManager](https://docs.arcade.dev/en/get-started/agent-frameworks/crewai/custom-auth-flow.md): This documentation page guides users on how to create a custom authorization flow for executing Arcade tools within their CrewAI team. It outlines the necessary prerequisites, environment setup, and configuration steps needed to implement a tailored authorization process, allowing for greater flexibility in handling tool
- [Providing useful tool errors](https://docs.arcade.dev/en/guides/create-tools/error-handling/useful-tool-errors.md): This documentation page teaches developers how to effectively handle errors when building tools with Arcade MCP, emphasizing the automatic error adaptation feature that reduces boilerplate code. It outlines the error handling philosophy, explains the use of error adapters, and provides guidance on when to raise
- [Pylon](https://docs.arcade.dev/en/resources/integrations/customer-support/pylon.md): The Pylon documentation provides agents with the necessary tools and API functionalities to manage issues, contacts, users, and teams within the Pylon MCP Server. Users can learn how to list and search issues, assign ownership, and interact with user and team data
- [Reddit](https://docs.arcade.dev/en/resources/integrations/social-communication/reddit.md): This documentation page provides users with a comprehensive guide to the Arcade Reddit MCP Server, which enables the development of agents and AI applications that can interact with Reddit. It details various tools available for actions such as submitting posts, commenting, retrieving content, and checking
@@ -248,6 +252,7 @@ Arcade delivers three core capabilities: Deploy agents even your security team w
- [Understanding `Context` and tools](https://docs.arcade.dev/en/guides/create-tools/tool-basics/runtime-data-access.md): This documentation page explains the `Context` class used in Arcade tools, detailing how to access runtime capabilities and tool-specific data securely. Users will learn how to utilize the `Context` object to retrieve OAuth tokens, secrets, user information, and to log
- [Use Arcade in Claude Desktop](https://docs.arcade.dev/en/get-started/mcp-clients/claude-desktop.md): This documentation page provides a step-by-step guide for users to connect Claude Desktop to an Arcade MCP Gateway, enabling them to utilize custom connectors. It outlines the prerequisites for setup, including creating an Arcade account and obtaining an API key, as well as detailed
- [Use Arcade in Cursor](https://docs.arcade.dev/en/get-started/mcp-clients/cursor.md): This documentation page provides a step-by-step guide for connecting Cursor to an Arcade MCP Gateway, enabling users to utilize Arcade tools within the Cursor environment. It outlines the prerequisites for setup, including creating an Arcade account and obtaining an API key, as well as
+- [Use Arcade in GitHub Copilot](https://docs.arcade.dev/en/get-started/mcp-clients/github-copilot.md): This documentation page provides a comprehensive guide on how to connect GitHub Copilot to an Arcade Gateway, enabling users to leverage the Arcade AI platform within their development environments. It outlines the prerequisites for setup, including creating an Arcade account and obtaining an API key
- [Use Arcade in Microsoft Copilot Studio](https://docs.arcade.dev/en/get-started/mcp-clients/copilot-studio.md): This documentation page guides users on how to connect Microsoft Copilot Studio to an Arcade MCP Gateway, enabling the integration of Arcade tools into their agents. It outlines the prerequisites, step-by-step instructions for creating or opening an agent, adding an MCP tool,
- [Use Arcade in Visual Studio Code](https://docs.arcade.dev/en/get-started/mcp-clients/visual-studio-code.md): This documentation page provides a step-by-step guide for connecting Visual Studio Code to an Arcade MCP Gateway, enabling users to set up and run an MCP server within the IDE. It outlines prerequisites, setup instructions, and authentication processes to ensure successful integration. By
- [VercelApi](https://docs.arcade.dev/en/resources/integrations/development/vercel-api.md): The VercelApi documentation provides a comprehensive guide for users to manage their Vercel projects, domains, and integrations through various API tools. It outlines available functionalities such as creating and managing access groups, handling deployments, and managing DNS records, enabling