diff --git a/app/en/home/langchain/_meta.tsx b/app/en/home/langchain/_meta.tsx
deleted file mode 100644
index a2708a562..000000000
--- a/app/en/home/langchain/_meta.tsx
+++ /dev/null
@@ -1,5 +0,0 @@
-export default {
- "use-arcade-tools": "Using Arcade tools",
- "user-auth-interrupts": "User authorization",
- "auth-langchain-tools": "Authorizing existing tools",
-};
diff --git a/app/en/home/langchain/use-arcade-tools/page.mdx b/app/en/home/langchain/use-arcade-tools/page.mdx
deleted file mode 100644
index 1ff3964c9..000000000
--- a/app/en/home/langchain/use-arcade-tools/page.mdx
+++ /dev/null
@@ -1,243 +0,0 @@
----
-title: "Use Arcade tools with LangGraph"
-description: "Integrate Arcade tools into your LangGraph applications"
----
-
-import { Steps, Tabs, Callout } from "nextra/components";
-
-## Use LangGraph with Arcade
-
-In this guide, let's explore how to integrate Arcade tools into your LangGraph application. Follow the step-by-step instructions below. For complete working examples, see our [Python](https://github.com/ArcadeAI/arcade-ai/blob/main/examples/langchain/langgraph_arcade_minimal.py) and [JavaScript](https://github.com/ArcadeAI/arcade-ai/blob/main/examples/langchain-ts/langgraph-arcade-minimal.ts) examples.
-
-
-
-### Prerequisites
-
-- [Obtain an Arcade API key](/home/api-keys)
-
-### Set up your environment
-
-Install the required packages, and ensure your environment variables are set with your Arcade and OpenAI API keys:
-
-
-
-```bash
-pip install langchain-arcade langchain-openai langgraph
-```
-
-
-```bash
-npm install @arcadeai/arcadejs @langchain/openai @langchain/core @langchain/langgraph
-```
-
-
-
-
-### Configure API keys
-
-Provide your Arcade and OpenAI API keys. You can store them in environment variables or directly in your code:
-
-> Need an Arcade API key? Visit the [Get an API key](/home/api-keys) page to create one.
-
-
-
-```python
-import os
-
-arcade_api_key = os.environ.get("ARCADE_API_KEY", "YOUR_ARCADE_API_KEY")
-openai_api_key = os.environ.get("OPENAI_API_KEY", "YOUR_OPENAI_API_KEY")
-```
-
-
-```bash
-ARCADE_API_KEY=
-OPENAI_API_KEY=
-```
-
-
-
-### Create and manage Arcade tools
-
-
-
-Use the ArcadeToolManager to retrieve specific tools or entire MCP Servers:
-
-```python
-from langchain_arcade import ArcadeToolManager
-
-manager = ArcadeToolManager(api_key=arcade_api_key)
-
-# Fetch the "ScrapeUrl" tool from the "Firecrawl" MCP Server
-tools = manager.get_tools(tools=["Firecrawl.ScrapeUrl"])
-print(manager.tools)
-
-# Get all tools from the "Gmail" MCP Server
-tools = manager.get_tools(toolkits=["Gmail"])
-print(manager.tools)
-```
-
-
-Arcade offers methods to convert tools into Zod schemas, which is essential since LangGraph defines tools using Zod. The `toZod` method is particularly useful, as it simplifies this integration and makes it easier to use Arcade's tools with LangGraph. Learn more about Arcade's Zod integration options [here](/home/use-tools/get-tool-definitions#get-zod-tool-definitions).
-```javascript
-import { Arcade } from "@arcadeai/arcadejs";
-import { executeOrAuthorizeZodTool, toZod } from "@arcadeai/arcadejs/lib";
-import { tool } from "@langchain/core/tools";
-
-// Initialize the Arcade client
-const arcade = new Arcade();
-
-// Get the Arcade tools, you can customize the MCP Server (e.g. "github", "notion", "gmail", etc.)
-const googleToolkit = await arcade.tools.list({ toolkit: "gmail", limit: 30 });
-const arcadeTools = toZod({
- tools: googleToolkit.items,
- client: arcade,
- userId: "", // Replace this with your application's user ID (e.g. email address, UUID, etc.)
-});
-// Convert Arcade tools to LangGraph tools
-const tools = arcadeTools.map(({ name, description, execute, parameters }) =>
- tool(execute, {
- name,
- description,
- schema: parameters,
- }),
-);
-console.log(tools);
-```
-
-
-
-
-### Set up the language model and memory
-
-Create an AI model and bind your tools. Use MemorySaver for checkpointing:
-
-
-
-```python
-from langchain_openai import ChatOpenAI
-from langgraph.checkpoint.memory import MemorySaver
-
-model = ChatOpenAI(model="gpt-4o", api_key=openai_api_key)
-bound_model = model.bind_tools(tools)
-
-memory = MemorySaver()
-```
-
-
-```javascript
-import { ChatOpenAI } from "@langchain/openai";
-import { MemorySaver } from "@langchain/langgraph";
-
-const model = new ChatOpenAI({ model: "gpt-4o", apiKey: process.env.OPENAI_API_KEY });
-const boundModel = model.bindTools(tools);
-const memory = new MemorySaver();
-```
-
-
-
-### Create a ReAct-style agent
-
-Use the prebuilt ReAct agent from LangGraph to handle your Arcade tools:
-
-
-```python
-from langgraph.prebuilt import create_react_agent
-
-graph = create_react_agent(model=bound_model, tools=tools, checkpointer=memory)
-```
-
-
-```javascript
-import { createReactAgent } from "@langchain/langgraph/prebuilt";
-
-const graph = createReactAgent({ llm: boundModel, tools, checkpointer: memory });
-```
-
-
-
-### Provide configuration and user query
-
-Supply a basic config dictionary and a user query. Notice that user_id is required for tool authorization:
-
-
-```python
-config = {
- "configurable": {
- "thread_id": "1",
- "user_id": "{arcade_user_id}"
- }
-}
-user_input = {
- "messages": [
- ("user", "List any new and important emails in my inbox.")
- ]
-}
-```
-
-
-```javascript
-const config = {
- configurable: {
- thread_id: "1",
- user_id: "{arcade_user_id}",
- },
- streamMode: "values" as const,
-};
-const user_input = {
- messages: [
- {
- role: "user",
- content: "List any new and important emails in my inbox.",
- },
- ],
-};
-```
-
-
-
-### Stream the response
-
-Stream the assistant's output. If the tool requires authorization, the agent will ask the user to authorize the tool.
-
-
-
-```python
-from langgraph.errors import NodeInterrupt
-
-try:
- for chunk in graph.stream(user_input, config, stream_mode="values"):
- chunk["messages"][-1].pretty_print()
-except NodeInterrupt as exc:
- print(f"\nNodeInterrupt occurred: {exc}")
- print("Please authorize the tool or update the request, then re-run.")
-```
-
-
-```javascript
-try {
- const stream = await graph.stream(user_input, config);
- for await (const chunk of stream) {
- console.log(chunk.messages[chunk.messages.length - 1]);
- }
-} catch (error) {
- console.error("Error streaming response:", error);
-}
-```
-
-
-
-
-## Tips for selecting tools
-
-- **Relevance**: Pick only the tools 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 LangGraph agent, you can:
-
-- Experiment with different MCP Servers, such as "Math" or "Search."
-- Customize the agent's prompts for specific tasks.
-- Try out other language models and compare their performance.
-
-Enjoy exploring Arcade and building powerful AI-enabled Python applications!
diff --git a/app/en/home/langchain/user-auth-interrupts/page.mdx b/app/en/home/langchain/user-auth-interrupts/page.mdx
deleted file mode 100644
index b03a57735..000000000
--- a/app/en/home/langchain/user-auth-interrupts/page.mdx
+++ /dev/null
@@ -1,373 +0,0 @@
----
-title: "Using Arcade User Auth"
-description: "Build a custom LangGraph that handles tool authorization with Arcade"
----
-
-import { Steps, Tabs, Callout } from "nextra/components";
-
-## User Authorization in LangGraph
-
-In this guide, you will create a LangGraph workflow that requires user authorization before running certain Arcade tools. When a tool needs authorization, the graph displays an authorization URL and waits for the user's approval. This ensures that only the tools you explicitly authorize are available to the language model. For complete working examples, see our [Python](https://github.com/ArcadeAI/arcade-ai/blob/main/examples/langchain/langgraph_with_user_auth.py) and [JavaScript](https://github.com/ArcadeAI/arcade-ai/blob/main/examples/langchain-ts/langgraph-with-user-auth.ts) examples.
-
-
-
-### Prerequisites
-
-- [Obtain an Arcade API key](/home/api-keys)
-
-### Install the required packages
-
-Set up your environment with the following installations:
-
-
-
-```bash
-pip install langchain-arcade langchain-openai langgraph
-```
-
-
-```bash
-npm install @arcadeai/arcadejs @langchain/openai @langchain/core @langchain/langgraph
-```
-
-
-
-### Configure your Arcade environment
-
-Make sure you have set your Arcade API key (and any other relevant keys) in the environment, or assign them directly in the code:
-
-> Need an Arcade API key? Visit the [Get an API key](/home/api-keys) page to create one.
-
-
-
-```python
-import os
-
-# Import necessary classes and modules
-from langchain_arcade import ArcadeToolManager
-from langchain_openai import ChatOpenAI
-from langgraph.checkpoint.memory import MemorySaver
-from langgraph.graph import END, START, MessagesState, StateGraph
-from langgraph.prebuilt import ToolNode
-from langchain_core.runnables import RunnableConfig
-
-arcade_api_key = os.environ["ARCADE_API_KEY"]
-
-# Initialize the tool manager and fetch tools compatible with langgraph
-tool_manager = ArcadeToolManager(api_key=arcade_api_key)
-tools = tool_manager.get_tools(toolkits=["Gmail"])
-tool_node = ToolNode(tools)
-
-# Create a language model instance and bind it with the tools
-model = ChatOpenAI(model="gpt-4o")
-model_with_tools = model.bind_tools(tools)
-```
-
-Here are the main code elements:
-
-- arcade_api_key is your Arcade key.
-- tool_manager fetches your Arcade tools, for example the "Gmail" MCP Server.
-- tool_node encapsulates these tools for usage in LangGraph.
-- model_with_tools binds your tools to the "gpt-4o" language model, enabling tool calls.
-
-
-
-```javascript
-import { pathToFileURL } from "node:url";
-import { Arcade } from "@arcadeai/arcadejs";
-import { toZod } from "@arcadeai/arcadejs/lib";
-import type { AIMessage } from "@langchain/core/messages";
-import { tool } from "@langchain/core/tools";
-import { MessagesAnnotation, StateGraph } from "@langchain/langgraph";
-import { ToolNode } from "@langchain/langgraph/prebuilt";
-import { ChatOpenAI } from "@langchain/openai";
-
-// Initialize Arcade with API key from environment
-const arcade = new Arcade();
-
-// Replace with your application's user ID (e.g. email address, UUID, etc.)
-const USER_ID = "{arcade_user_id}";
-
-// Initialize tools from Gmail MCP Server
-const googleToolkit = await arcade.tools.list({ toolkit: "gmail", limit: 30 });
-const arcadeTools = toZod({
- tools: googleToolkit.items,
- client: arcade,
- userId: USER_ID,
-});
-
-// Convert Arcade tools to LangGraph tools
-const tools = arcadeTools.map(({ name, description, execute, parameters }) =>
- tool(execute, {
- name,
- description,
- schema: parameters,
- }),
-);
-
-// Initialize the prebuilt tool node
-const toolNode = new ToolNode(tools);
-
-// Create a language model instance and bind it with the tools
-const model = new ChatOpenAI({
- model: "gpt-4o",
- apiKey: process.env.OPENAI_API_KEY,
-});
-const modelWithTools = model.bindTools(tools);
-```
-
-Here are the main code elements:
-
-- arcade.tools.list fetches your Arcade tools, for example the "Gmail" MCP Server.
-- toZod converts Arcade tools to Zod schemas, which are required by LangGraph.
-- ToolNode encapsulates these tools for usage in LangGraph.
-- modelWithTools binds your tools to the "gpt-4o" language model, enabling tool calls.
-
-
-
-
-### Define the workflow steps
-
-You will create three primary functions to handle AI interaction, tool authorization, and flow control.
-
-
-```python
-# Function to invoke the model and get a response
-def call_agent(state: MessagesState):
- messages = state["messages"]
- response = model_with_tools.invoke(messages)
- # Return the updated message history
- return {"messages": [response]}
-
-
-# Function to determine the next step in the workflow based on the last message
-def should_continue(state: MessagesState):
- if state["messages"][-1].tool_calls:
- for tool_call in state["messages"][-1].tool_calls:
- if tool_manager.requires_auth(tool_call["name"]):
- return "authorization"
- return "tools" # Proceed to tool execution if no authorization is needed
- return END # End the workflow if no tool calls are present
-
-
-# Function to handle authorization for tools that require it
-def authorize(state: MessagesState, config: RunnableConfig | None = None):
- if config is None:
- raise ValueError("Config is required for authorization")
-
- user_id = config["configurable"].get("user_id")
- for tool_call in state["messages"][-1].tool_calls:
- tool_name = tool_call["name"]
- if not tool_manager.requires_auth(tool_name):
- continue
- auth_response = tool_manager.authorize(tool_name, user_id)
- if auth_response.status != "completed":
- # Prompt the user to visit the authorization URL
- print(f"Visit the following URL to authorize: {auth_response.url}")
-
- # Wait for the user to complete the authorization
- # and then check the authorization status again
- tool_manager.wait_for_auth(auth_response.id)
- if not tool_manager.is_authorized(auth_response.id):
- # This stops execution if authorization fails
- raise ValueError("Authorization failed.")
-
- return {"messages": []}
-```
-Explanations for these functions:
-
-- call_agent: Invokes the language model using the latest conversation state.
-- should_continue: Checks the last AI message for any tool calls. If a tool requires authorization, the flow transitions to authorization. Otherwise, it goes straight to tool execution or ends if no tools are called.
-- authorize: Prompts the user to authorize any required tools, blocking until authorization is completed successfully or fails.
-
-
-```javascript
-// Function to check if a tool requires authorization
-async function requiresAuth(toolName: string): Promise<{
- needsAuth: boolean;
- id: string;
- authUrl: string;
-}> {
- const authResponse = await arcade.tools.authorize({
- tool_name: toolName,
- user_id: USER_ID,
- });
- return {
- needsAuth: authResponse.status === "pending",
- id: authResponse.id ?? "",
- authUrl: authResponse.url ?? "",
- };
-}
-
-// Function to invoke the model and get a response
-async function callAgent(
- state: typeof MessagesAnnotation.State,
-): Promise {
- const messages = state.messages;
- const response = await modelWithTools.invoke(messages);
- return { messages: [response] };
-}
-
-// Function to determine the next step in the workflow based on the last message
-async function shouldContinue(
- state: typeof MessagesAnnotation.State,
-): Promise {
- const lastMessage = state.messages[state.messages.length - 1] as AIMessage;
- if (lastMessage.tool_calls?.length) {
- for (const toolCall of lastMessage.tool_calls) {
- const { needsAuth } = await requiresAuth(toolCall.name);
- if (needsAuth) {
- return "authorization";
- }
- }
- return "tools"; // Proceed to tool execution if no authorization is needed
- }
- return "__end__"; // End the workflow if no tool calls are present
-}
-
-// Function to handle authorization for tools that require it
-async function authorize(
- state: typeof MessagesAnnotation.State,
-): Promise {
- const lastMessage = state.messages[state.messages.length - 1] as AIMessage;
- for (const toolCall of lastMessage.tool_calls || []) {
- const toolName = toolCall.name;
- const { needsAuth, id, authUrl } = await requiresAuth(toolName);
- if (needsAuth) {
- // Prompt the user to visit the authorization URL
- console.log(`Visit the following URL to authorize: ${authUrl}`);
-
- // Wait for the user to complete the authorization
- const response = await arcade.auth.waitForCompletion(id);
- if (response.status !== "completed") {
- throw new Error("Authorization failed");
- }
- }
- }
-
- return { messages: [] };
-}
-```
-
-Explanations for these functions:
-
-- requiresAuth: Checks if a tool requires authorization.
-- callAgent: Invokes the language model using the latest conversation state.
-- shouldContinue: Checks the last AI message for any tool calls. If a tool requires authorization, the flow transitions to authorization. Otherwise, it goes straight to tool execution or ends if no tools are called.
-- authorize: Prompts the user to authorize any required tools, blocking until authorization is completed successfully or fails.
-
-
-
-
-### Build and compile your LangGraph workflow
-
-Use StateGraph to assemble the nodes and edges, then compile the graph with a MemorySaver.
-
-
-
-```python
-if __name__ == "__main__":
- # Build the workflow graph using StateGraph
- workflow = StateGraph(MessagesState)
-
- # Add nodes (steps) to the graph
- workflow.add_node("agent", call_agent)
- workflow.add_node("tools", tool_node)
- workflow.add_node("authorization", authorize)
-
- # Define the edges and control flow between nodes
- workflow.add_edge(START, "agent")
- workflow.add_conditional_edges("agent", should_continue, ["authorization", "tools", END])
- workflow.add_edge("authorization", "tools")
- workflow.add_edge("tools", "agent")
-
- # Set up memory for checkpointing the state
- memory = MemorySaver()
-
- # Compile the graph with the checkpointer
- graph = workflow.compile(checkpointer=memory)
-```
-
-
-```javascript
-// Build the workflow graph
-const workflow = new StateGraph(MessagesAnnotation)
- .addNode("agent", callAgent)
- .addNode("tools", toolNode)
- .addNode("authorization", authorize)
- .addEdge("__start__", "agent")
- .addConditionalEdges("agent", shouldContinue, [
- "authorization",
- "tools",
- "__end__",
- ])
- .addEdge("authorization", "tools")
- .addEdge("tools", "agent");
-
-// Compile the graph
-const graph = workflow.compile();
-```
-
-
-
-### Provide inputs and run the graph
-
-Finally, define user-supplied messages, authorization config, and stream the outputs. The graph will pause for any required tool authorization.
-
-
-
-```python
-# Define the input messages from the user
-inputs = {
- "messages": [
- {
- "role": "user",
- "content": "Check and see if I have any emails in my inbox",
- }
- ],
-}
-
-# Configuration with thread and user IDs for authorization purposes
-config = {"configurable": {"thread_id": "4", "user_id": "{arcade_user_id}"}}
-
-# Run the graph and stream the outputs
-for chunk in graph.stream(inputs, config=config, stream_mode="values"):
- # Pretty-print the last message in the chunk
- chunk["messages"][-1].pretty_print()
-```
-
-
-```javascript
-const inputs = {
- messages: [
- {
- role: "user",
- content: "Check and see if I have any important emails in my inbox",
- },
- ],
-};
-// Run the graph and stream the outputs
-const stream = await graph.stream(inputs, { streamMode: "values" });
-for await (const chunk of stream) {
- // Print the last message in the chunk
- console.log(chunk.messages[chunk.messages.length - 1].content);
-}
-```
-
-
-
-In this example:
-
-- The user prompts the agent to check emails.
-- The message triggers a potential need for the "Gmail" MCP Server.
-- If authorization is required, the code prints a URL and waits until you permit the tool call.
-
-
-
-## Next steps
-
-- Experiment with more Arcade MCP Servers for expanded capabilities.
-- Explore advanced authorization logic, such as multi-user or role-based checks.
-- Integrate additional nodes to handle more complex flows or multi-step tasks in your LangGraph.
-
-By combining Arcade's authorization features with stateful management in LangGraph, you can build AI-driven workflows that respect user permissions at every step. Have fun exploring Arcade!
diff --git a/app/en/home/mastra/overview/page.mdx b/app/en/home/mastra/overview/page.mdx
deleted file mode 100644
index e61b3f3c5..000000000
--- a/app/en/home/mastra/overview/page.mdx
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: "Integrating Arcade with Mastra"
-description: "Leverage Arcade's tool ecosystem within your Mastra applications."
----
-
-import { Callout } from "nextra/components";
-
-## Overview: Arcade Tools in Mastra
-
-[Mastra](https://mastra.ai/docs) is an open-source TypeScript agent framework that provides essential primitives for building AI applications. Integrate Arcade's extensive tool ecosystem to enhance your Mastra agents and enable them to interact seamlessly with numerous third-party services.
-
-This integration enables you to:
-
-- **Access a wide range of tools:** Use Arcade's [pre-built tools](/mcp-servers) for GitHub, Google Workspace, Slack, and more directly within your Mastra agent.
-- **Simplify tool management:** Let Arcade handle the complexities of tool discovery, execution, and authentication.
-- **Build sophisticated agents:** Combine Mastra's agent framework (including memory, workflows, and RAG) with Arcade's powerful tool capabilities.
-
-### How it Works
-
-The integration works through three key mechanisms:
-
-1. **Tool Discovery:** Access available tools through a unified API (`arcade.tools.list`).
-2. **Schema Conversion:** Transform Arcade's tool definitions into Mastra-compatible Zod schemas with the `toZodToolSet` utility, enabling seamless integration between the two frameworks without manual schema mapping.
-3. **Execution Delegation:** Seamlessly route tool calls from your Mastra agent through Arcade's API, which handles all the complexities of third-party service authentication and execution.
-
-
- Before starting, obtain an [Arcade API key](/home/api-keys).
-
-
-### Next Steps
-
-- Learn how to [use Arcade tools](/home/mastra/use-arcade-tools) in a Mastra agent
-- Implement [user authentication handling](/home/mastra/user-auth-interrupts) for tools in multi-user applications
diff --git a/app/en/home/mastra/use-arcade-tools/page.mdx b/app/en/home/mastra/use-arcade-tools/page.mdx
deleted file mode 100644
index 1e7b0919f..000000000
--- a/app/en/home/mastra/use-arcade-tools/page.mdx
+++ /dev/null
@@ -1,161 +0,0 @@
----
-title: "Using Arcade tools with Mastra"
-description: "Integrate Arcade tools into your Mastra applications for basic use cases."
----
-
-import { Steps, Tabs, Callout } from "nextra/components";
-
-This guide shows you how to integrate and use Arcade tools within a Mastra agent. For the complete working example, check out our [GitHub repository](https://github.com/ArcadeAI/arcade-ai/tree/main/examples/mastra).
-
-
-
-### Prerequisites
-
-- [Obtain an Arcade API key](/home/api-keys)
-- Basic familiarity with TypeScript and Mastra concepts
-
-### Create a Mastra project
-
-Start by creating a new Mastra project using the official CLI:
-
-```bash
-# Create a new Mastra project
-npx create-mastra@latest my-arcade-agent
-
-# Navigate to the project
-cd my-arcade-agent
-```
-
-For more details on setting up a Mastra project, refer to the [Mastra documentation](https://mastra.ai/docs/getting-started/installation).
-
-### Install Arcade client
-
-Install the Arcade client:
-
-
-
-
-
-```bash
-pnpm add @arcadeai/arcadejs
-```
-
-
-
-
-
-```bash
-npm install @arcadeai/arcadejs
-```
-
-
-
-
-
-```bash
-yarn install @arcadeai/arcadejs
-```
-
-
-
-
-
-### Configure API keys
-
-Set up your environment with the required API keys:
-
-```typescript
-// Set your API keys in your environment variables or .env file
-process.env.ARCADE_API_KEY = "your_arcade_api_key";
-process.env.ANTHROPIC_API_KEY = "your_anthropic_api_key"; // or another supported model provider
-```
-
-### Convert Arcade tools to Mastra tools
-
-Arcade offers methods to convert tools into Zod schemas, which is essential since Mastra defines tools using Zod. The `toZodToolSet` method is particularly useful, as it simplifies this integration and makes it easier to use Arcade's tools with Mastra. Learn more about Arcade's Zod integration options [here](/home/use-tools/get-tool-definitions#get-zod-tool-definitions).
-
-```ts
-import { Arcade } from "@arcadeai/arcadejs";
-import {
- executeOrAuthorizeZodTool,
- toZodToolSet,
-} from "@arcadeai/arcadejs/lib";
-
-// Initialize Arcade
-const arcade = new Arcade();
-
-// Get Gmail MCP Server
-// MCP Server names can be found in the Arcade dashboard via Tools > view > MCP Server or via the CLI `arcade workers list`
-const gmailToolkit = await arcade.tools.list({ toolkit: "Gmail", limit: 30 });
-
-// Get Gmail tools
-export const gmailTools = toZodToolSet({
- tools: gmailToolkit.items,
- client: arcade,
- userId: "", // Your app's internal ID for the user (an email, UUID, etc). It's used internally to identify your user in Arcade
- executeFactory: executeOrAuthorizeZodTool, // Checks if tool is authorized and executes it, or returns authorization URL if needed
-});
-
-```
-
-### Create and configure your Mastra agent
-
-Now create a Mastra agent that uses Arcade tools:
-
-```typescript
-import { Agent } from "@mastra/core/agent";
-import { anthropic } from "@ai-sdk/anthropic";
-
-// Create the Mastra agent with Arcade tools
-export const gmailAgent = new Agent({
- name: "gmailAgent",
- instructions: `You are a Gmail assistant that helps users manage their inbox.
-
-When helping users:
-- Always verify their intent before performing actions
-- Keep responses clear and concise
-- Confirm important actions before executing them
-- Respect user privacy and data security
-
-Use the gmailTools to interact with various Gmail services and perform related tasks.`,
- model: anthropic("claude-3-7-sonnet-20250219"),
- tools: gmailTools,
-});
-```
-
-### Interact with your agent
-
-You can interact with your agent in two main ways:
-
-**1. Using the Mastra Development Playground:**
-
-Start the Mastra development server:
-
-```bash
-npm run dev
-```
-
-This will launch a local development playground, typically accessible at `http://localhost:4111`. Open this URL in your browser, select the `gmailAgent` from the list of available agents, and start chatting with it directly in the UI.
-
-**2. Programmatically:**
-
-Alternatively, you can interact with the agent directly in your code:
-
-```typescript
-// Generate a response from the agent
-const response = await gmailAgent.generate(
- "Read my last email and summarize it in a few sentences",
-);
-console.log(response.text);
-
-// Or stream the response for a more interactive experience
-const stream = await gmailAgent.stream("Send an email to dev@arcade.dev with the subject 'Hello from Mastra'");
-
-for await (const chunk of stream.textStream) {
- process.stdout.write(chunk);
-}
-```
-
-
-
-
When running your agent for the first time with tools that require user consent (like Google or Github), the agent will return an authorization reponse (e.g., `{ authorization_required: true, url: '...', message: '...' }`). Your agent's instructions should guide it to present this URL to the user. After the user visits this URL and grants permissions, the tool can be used successfully. See the [Managing user authorization](/home/mastra/user-auth-interrupts) guide for more details on handling authentication flows.
diff --git a/app/en/home/mastra/user-auth-interrupts/page.mdx b/app/en/home/mastra/user-auth-interrupts/page.mdx
deleted file mode 100644
index eea1f31dc..000000000
--- a/app/en/home/mastra/user-auth-interrupts/page.mdx
+++ /dev/null
@@ -1,153 +0,0 @@
----
-title: "Managing user authorization"
-description: "Handle user-specific authorization for Arcade tools in Mastra applications."
----
-
-import { Callout } from "nextra/components";
-
-## Dynamic Tool Loading with Toolsets
-
-Mastra lets you dynamically provide tools to an agent at runtime using toolsets. This approach is essential when integrating Arcade tools in web applications where each user needs their own authentication flow.
-
-### Per-User Tool Authentication in Web Applications
-
-In web applications serving multiple users, implement user-specific authentication flows with these steps:
-
-First, set up your Mastra configuration and agents in separate files:
-
-```typescript
-// @/mastra/index.ts
-import { Mastra } from "@mastra/core";
-import { githubAgent } from "./agents/githubAgent";
-
-// Initialize Mastra
-export const mastra = new Mastra({
- agents: {
- githubAgent,
- },
-});
-```
-
-```typescript
-// @/mastra/agents/githubAgent.ts
-import { Agent } from "@mastra/core/agent";
-import { anthropic } from "@ai-sdk/anthropic";
-
-// Create the agent without tools - we'll add them at runtime
-export const githubAgent = new Agent({
- name: "githubAgent",
- instructions: `You are a GitHub Agent that helps with repository management.
-
- You can help with tasks like:
- - Listing repositories
- - Creating and managing issues
- - Viewing pull requests
- - Managing repository settings
-
- If a tool requires authorization, you will receive an authorization URL.
- When that happens, clearly present this URL to the user and ask them to visit it to grant permissions.`,
- model: anthropic("claude-3-7-sonnet-20250219"),
- // No tools defined here - will be provided dynamically at runtime
-});
-```
-
-Then, create an API endpoint that provides tools dynamically:
-
-```typescript
-// app/api/chat/route.ts
-import { NextRequest, NextResponse } from "next/server";
-import { mastra } from "@/mastra";
-import { Arcade } from "@arcadeai/arcadejs";
-import { getUserSession } from "@/lib/auth"; // Your authentication handling
-import { toZodToolSet } from "@arcadeai/arcadejs/lib";
-import { executeOrAuthorizeZodTool } from "@arcadeai/arcadejs/lib";
-
-export async function POST(req: NextRequest) {
- // Extract request data
- const { messages, threadId } = await req.json();
-
- // Authenticate the user
- const session = await getUserSession(req);
- if (!session) {
- return NextResponse.json({ message: "Unauthorized" }, { status: 401 });
- }
-
- try {
- // Get the agent from Mastra
- const githubAgent = mastra.getAgent("githubAgent");
-
- const arcade = new Arcade();
- const githubToolkit = await arcade.tools.list({ toolkit: "github", limit: 30 });
-
- // Fetch user-specific Arcade tools for GitHub
- const arcadeTools = toZodToolSet({
- tools: githubToolkit.items,
- client: arcade,
- userId: session.user.email,
- executeFactory: executeOrAuthorizeZodTool,
- });
-
- // Stream the response with dynamically provided tools
- const response = await githubAgent.stream(messages, {
- threadId, // Optional: For maintaining conversation context
- resourceId: session.user.id, // Optional: For associating memory with user
- toolChoice: "auto",
- toolsets: {
- arcade: arcadeTools, // Provide tools in a named toolset
- },
- });
-
- // Return streaming response
- return response.toDataStreamResponse();
- } catch (error) {
- console.error("Error processing GitHub request:", error);
- return NextResponse.json(
- { message: "Failed to process request" },
- { status: 500 },
- );
- }
-}
-```
-
-This approach provides several benefits:
-
-- Each user gets their own separate authentication flow with Arcade tools
-- A single agent instance works with multiple user-specific toolsets
-
-
The toolsets parameter provides tools only for the current request without modifying the agent's base configuration. This makes it ideal for multi-user applications where each user needs their own secure OAuth flow with Arcade.
-
-## Handling Tool Authorization
-
-When a tool requires user authorization, the agent receives a response with:
-
-```typescript
-{
- authorization_required: true,
- url: "https://auth.arcade.com/...",
- message: "Forward this url to the user for authorization"
-}
-```
-
-Your agent should recognize this pattern and present the URL to the user. To create a better user experience:
-
-- Display the authorization URL as a clickable link in your UI
-- Explain which service needs authorization and why
-- Provide a way for users to retry their request after authorization
-
-## Tips for Selecting Tools
-
-- **Focus on relevance**: Choose tools that directly support your agent's specific purpose
-- **Consider performance**: Some tools may have higher latency than others
-- **Handle errors gracefully**: Implement robust error handling for third-party service failures
-- **Create clear user flows**: Design intuitive authorization experiences
-
-## Next Steps
-
-After integrating Arcade tools into your Mastra agent, you can:
-
-- Add [memory capabilities](https://mastra.ai/docs/agents/agent-memory) to maintain context between interactions
-- Implement [structured workflows](https://mastra.ai/docs/workflows/overview) for complex multi-step operations
-- Enhance your agent with [RAG capabilities](https://mastra.ai/docs/rag/overview) for domain-specific knowledge
-- Set up [logging and tracing](https://mastra.ai/docs/observability/logging) to monitor performance
-
-For more detailed information on Mastra's capabilities, visit the [Mastra documentation](https://mastra.ai/docs).
diff --git a/app/en/home/mcp-gateway-quickstart/page.mdx b/app/en/home/mcp-gateway-quickstart/page.mdx
new file mode 100644
index 000000000..28d4b7d4b
--- /dev/null
+++ b/app/en/home/mcp-gateway-quickstart/page.mdx
@@ -0,0 +1,25 @@
+# MCP Gateway Quickstart
+
+This is a placeholder page for the MCP Gateway quickstart guide.
+
+## Overview
+
+Learn how to call tools in 3rd party agents, apps, or IDEs using the MCP Gateway.
+
+## Prerequisites
+
+- Arcade API key
+- Supported MCP client
+
+## Setup Steps
+
+1. Configure your MCP Gateway
+2. Connect to your client application
+3. Test tool calling functionality
+
+## Supported Clients
+
+- Cursor
+- Claude Desktop
+- Visual Studio Code
+- Other MCP-compatible applications
\ No newline at end of file
diff --git a/app/en/home/mcp-gateways/page.mdx b/app/en/home/mcp-gateways/page.mdx
deleted file mode 100644
index 17cd6f869..000000000
--- a/app/en/home/mcp-gateways/page.mdx
+++ /dev/null
@@ -1,29 +0,0 @@
----
-title: "MCP Gateways"
-description: "Comprehensive guide to using MCP Gateways"
----
-
-# MCP Gateways
-
-MCP Gateways are a way to connect multiple MCP Servers to your agent, application, or IDE. MCP Gateways allow you to federate the tools from multiple MCP Servers into a single collection for easier management, control, and access. You can mix and match tools from different MCP Servers in the same project, and not all tools from a MCP server need to be available to the same LLM.
-
-## Configure MCP Gateways
-
-To configure an MCP Gateway, go to the [MCP Gateways dashboard](https://api.arcade.dev/dashboard/mcp-gateways) and click on the "Create MCP Gateway" button.
-
-When configuring an MCP Gateway, you can select the tools you want to include in the Gateway from any MCP Servers available to the project:
-
-
-
-The options available when configuring an MCP Gateway are:
-- **Name**: The name of the MCP Gateway. Informative only.
-- **Description**: The description of the MCP Gateway. If set, this information will be returned to the LLM to hint at the purpose of the tools within the MCP Gateway.
-- **Slug**: The slug of the MCP Gateway. This is the URL slug that will be used to access the MCP Gateway. It must be unique.
-- **Allowed Tools**: If set, only the tools in the MCP Servers that are selected will be available to the MCP Gateway. If left blank, all tools from the MCP Servers available to the project will be available through the MCP Gateway.
-
-## How to use MCP Gateways
-
-Any MCP client that supports the Streamable HTTP transport can use an Arcade MCP Gateway. To use an Arcade MCP Gateway, you can use the `https://api.arcade.dev/mcp/
` URL in your MCP client. Learn how to use MCP Gateways with:
-* [Cursor](/home/mcp-clients/cursor)
-* [Claude Desktop](/home/mcp-clients/claude-desktop)
-* [Visual Studio Code](/home/mcp-clients/visual-studio-code)
diff --git a/app/en/home/oai-agents/_meta.tsx b/app/en/home/oai-agents/_meta.tsx
deleted file mode 100644
index cdb53979a..000000000
--- a/app/en/home/oai-agents/_meta.tsx
+++ /dev/null
@@ -1,5 +0,0 @@
-export default {
- overview: "Overview",
- "use-arcade-tools": "Using Arcade tools",
- "user-auth-interrupts": "Managing user authorization",
-};
diff --git a/app/en/home/oai-agents/overview/page.mdx b/app/en/home/oai-agents/overview/page.mdx
deleted file mode 100644
index 27eaa1f72..000000000
--- a/app/en/home/oai-agents/overview/page.mdx
+++ /dev/null
@@ -1,184 +0,0 @@
----
-title: "Arcade with OpenAI Agents overview"
-description: "Comprehensive guide to using Arcade with the OpenAI Agents library"
----
-
-import { Steps, Tabs, Callout } from "nextra/components";
-
-# Arcade with OpenAI Agents
-
-Arcade provides seamless integration with the [OpenAI Agents Library](https://github.com/openai/openai-python) and [OpenAI Agents JS](https://openai.github.io/openai-agents-js/), allowing you to enhance your AI agents with powerful tools including Gmail, LinkedIn, GitHub, and many more. This integration is available through the `agents-arcade` package for Python and our [JavaScript client library](https://github.com/ArcadeAI/arcade-js).
-
-## Installation
-
-Install the necessary packages to get started:
-
-
-
-
-```bash
-pip install agents-arcade arcadepy
-```
-
-
-
-
-
-```bash
-npm install @openai/agents @arcadeai/arcadejs
-```
-
-
-
-
-
-Make sure you have your Arcade API key ready. [Get an API key](/home/api-keys) if you don't already have one.
-
-## Key features
-
-- **Easy integration** with the OpenAI Agents framework
-- **Access to all Arcade MCP Servers** including Google, GitHub, LinkedIn, X, and more
-- **Create custom tools** with the Arcade Tool SDK
-- **Manage user authentication** for tools that require it
-- **Asynchronous support** compatible with OpenAI's Agent framework
-
-## Basic usage
-
-Here's a simple example of using Arcade tools with OpenAI Agents:
-
-
-
-
-```python
-from agents import Agent, Runner
-from arcadepy import AsyncArcade
-from agents_arcade import get_arcade_tools
-from agents_arcade.errors import AuthorizationError
-
-async def main():
- # Initialize the Arcade client
- client = AsyncArcade()
-
- # Get tools from the "gmail" MCP Server
- tools = await get_arcade_tools(client, toolkits=["gmail"])
-
- # Create an agent with Gmail tools
- google_agent = Agent(
- name="Gmail agent",
- instructions="You are a helpful assistant that can assist with Gmail API calls.",
- model="gpt-4o-mini",
- tools=tools,
- )
-
- try:
- # Run the agent with a unique user_id for authorization
- result = await Runner.run(
- starting_agent=google_agent,
- input="What are my latest emails?",
- context={"user_id": "{arcade_user_id}"},
- )
- print("Final output:\n\n", result.final_output)
- except AuthorizationError as e:
- print("Please Login to Google:", e)
-
-if __name__ == "__main__":
- import asyncio
- asyncio.run(main())
-```
-
-
-
-
-
-Check out the complete working example in our [GitHub repository](https://github.com/ArcadeAI/arcade-ai/tree/main/examples/openai-agents-ts/src/index.ts).
-
-```javascript
-import Arcade from "@arcadeai/arcadejs";
-import { executeOrAuthorizeZodTool, toZod } from "@arcadeai/arcadejs/lib";
-import { Agent, run, tool } from "@openai/agents";
-
-// 1) Initialize Arcade client
-const client = new Arcade();
-
-// 2) Fetch Gmail MCP Server from Arcade and prepare tools for OpenAI Agents
-const googleToolkit = await client.tools.list({ toolkit: "gmail", limit: 30 });
-const tools = toZod({
- tools: googleToolkit.items,
- client,
- userId: "", // Replace this with your application's user ID (e.g. email address, UUID, etc.)
- executeFactory: executeOrAuthorizeZodTool,
-}).map(tool);
-
-// 3) Create a new agent with the Gmail MCP Server
-const googleAgent = new Agent({
- name: "Gmail agent",
- instructions:
- "You are a helpful assistant that can assist with Google API calls.",
- model: "gpt-4o-mini",
- tools,
-});
-
-// 4) Run the agent
-const result = await run(googleAgent, "What are my latest emails?");
-
-// 5) Print the result
-console.log(result.finalOutput);
-```
-
-
-
-
-
-## Handling authorization
-
-
-
-
-When a user needs to authorize access to a tool (like Google or GitHub), the agent will raise an `AuthorizationError` with a URL for the user to visit:
-
-```python
-try:
- # Run agent code
- # ...
-except AuthorizationError as e:
- # Display the authorization URL to the user
- print(f"Please visit this URL to authorize: {e}")
-```
-
-
-
-
-
-When a user needs to authorize access to a tool (like Google or GitHub), the agent will show a message like this:
-
-```bash
-[Authorize Gmail Access](https://accounts.google.com/o/oauth2/v2/auth?access_type=offline...)
-Once you have authorized access, I can retrieve your latest emails.
-```
-
-
-
-
-After visiting the URL and authorizing access, the user can run the agent again with the same `user_id`, and it will work without requiring re-authorization.
-
-## Available MCP Servers
-
-Arcade provides a variety of MCP Servers you can use with your agents:
-
-- **Google Suite**: Gmail, Calendar, Drive, Docs
-- **Social Media**: LinkedIn, X
-- **Development**: GitHub
-- **Web**: Web search, content extraction
-- **And more**: Weather, financial data, etc.
-
-For a full list of available MCP Servers, visit the [Arcade MCP Servers](/mcp-servers) documentation.
-
-## Next steps
-
-Ready to start building with Arcade and OpenAI Agents? Check out these guides:
-
-- [Using Arcade tools](/home/oai-agents/use-arcade-tools) - Learn the basics of using Arcade tools with OpenAI Agents
-- [Managing user authorization](/home/oai-agents/user-auth-interrupts) - Handle tool authorization efficiently
-- [Creating custom tools](/home/build-tools/create-a-mcp-server) - Build your own tools with the Arcade Tool SDK
-
-Enjoy exploring Arcade and building powerful AI-enabled applications!
diff --git a/app/en/home/oai-agents/use-arcade-tools/page.mdx b/app/en/home/oai-agents/use-arcade-tools/page.mdx
deleted file mode 100644
index 0b098f28c..000000000
--- a/app/en/home/oai-agents/use-arcade-tools/page.mdx
+++ /dev/null
@@ -1,346 +0,0 @@
----
-title: "Use Arcade with OpenAI Agents"
-description: "Integrate Arcade tools into your OpenAI Agents applications"
----
-import { Steps, Tabs, Callout } from "nextra/components";
-
-## Use Arcade with OpenAI Agents
-
-In this guide, let's explore how to integrate Arcade tools into your OpenAI Agents application. Follow the step-by-step instructions below.
-
-
-
-### Prerequisites
-
-- [Obtain an Arcade API key](/home/api-keys)
-
-### Set up your environment
-
-Install the required packages, and ensure your environment variables are set with your Arcade API key:
-
-
-
-
-
-```bash
-pip install agents-arcade arcadepy
-```
-
-
-
-
-
-```bash
-npm install @openai/agents @arcadeai/arcadejs
-```
-
-
-
-
-
-### Configure API keys
-
-Provide your Arcade API key. You can store it in environment variables or directly in your code:
-
-> Need an Arcade API key? Visit the [Get an API key](/home/api-keys) page to create one.
-
-
-
-
-```python
-import os
-
-os.environ["ARCADE_API_KEY"] = "YOUR_ARCADE_API_KEY"
-# Or set it directly when initializing the client
-```
-
-
-
-
-
-```bash
-# In your .env file
-ARCADE_API_KEY=YOUR_ARCADE_API_KEY
-```
-
-
-
-
-
-
-
-### Create and manage Arcade tools
-
-
-
-
-Use the `get_arcade_tools` function to retrieve tools from specific MCP Servers:
-
-```python
-from arcadepy import AsyncArcade
-from agents_arcade import get_arcade_tools
-
-# Initialize the Arcade client
-client = AsyncArcade()
-
-# Get all tools from the "Gmail" MCP Server
-tools = await get_arcade_tools(client, toolkits=["gmail"])
-
-# You can request multiple MCP Servers at once
-tools = await get_arcade_tools(client, toolkits=["gmail", "github", "linkedin"])
-
-# You can request specific tools
-tools = await get_arcade_tools(client, tools=["Gmail_ListEmails", "Slack_ListUsers", "Slack_SendDmToUser"])
-```
-
-
-
-
-
-```javascript
-import Arcade from '@arcadeai/arcadejs';
-import { executeOrAuthorizeZodTool, toZod } from "@arcadeai/arcadejs/lib";
-import { tool } from '@openai/agents';
-
-const client = new Arcade();
-
-// Option 1: Get tools from a single MCP Server
-const googleTools = await client.tools.list({ toolkit: "gmail", limit: 30 });
-const toolsFromGoogle = googleTools.items;
-
-// Option 2: Get tools from multiple MCP Servers
-const [google, github, linkedin] = await Promise.all([
- client.tools.list({ toolkit: "gmail", limit: 30 }),
- client.tools.list({ toolkit: "github", limit: 30 }),
- client.tools.list({ toolkit: "linkedin", limit: 30 })
-]);
-const toolsFromMultiple = [...google.items, ...github.items, ...linkedin.items];
-
-// Option 3: Get specific tools by name
-const specificTools = await Promise.all([
- client.tools.get("Gmail_ListEmails"),
- client.tools.get("Slack_ListUsers"),
- client.tools.get("Slack_SendDmToUser"),
-]);
-
-// Convert any of the above to OpenAI Agents format
-const convertToAgents = (arcadeTools) => {
- return toZod({
- tools: arcadeTools,
- client,
- userId: "", // Replace this with your application's user ID (e.g. email address, UUID, etc.)
- executeFactory: executeOrAuthorizeZodTool,
- }).map(tool);
-};
-
-// Use with any of the options above
-const tools = convertToAgents(toolsFromGoogle); // or toolsFromMultiple or specificTools
-```
-
-
-
-
-
-### Set up the agent with Arcade tools
-
-Create an agent and provide it with the Arcade tools:
-
-
-
-
-```python
-from agents import Agent, Runner
-
-# Create an agent with Gmail tools
-google_agent = Agent(
- name="Gmail agent",
- instructions="You are a helpful assistant that can assist with Google API calls.",
- model="gpt-4o-mini",
- tools=tools,
-)
-```
-
-
-
-
-
-```javascript
-import { Agent, Runner, tool } from '@openai/agents';
-
-// Create an agent with Arcade tools
-const googleAgent = new Agent({
- name: "Gmail agent",
- instructions: "You are a helpful assistant that can assist with Google API calls.",
- model: "gpt-4o-mini",
- tools
-});
-```
-
-
-
-
-### Run the agent
-
-
-
-
-Run the agent, providing a user_id for tool authorization:
-
-```python
-try:
- result = await Runner.run(
- starting_agent=google_agent,
- input="What are my latest emails?",
- context={"user_id": "{arcade_user_id}"},
- )
- print("Final output:\n\n", result.final_output)
-except AuthorizationError as e:
- print("Please Login to Google:", e)
-```
-
-
-
-
-```javascript
-const result = await run(googleAgent, "What are my latest emails?");
-```
-
-
-
-
-
-
-### Handle authentication
-
-
-
-
-If a tool requires authorization, an `AuthorizationError` will be raised with an authorization URL:
-
-```python
-from agents_arcade.errors import AuthorizationError
-
-try:
- # Run agent code from earlier examples
- # ...
-except AuthorizationError as e:
- print(f"Please visit this URL to authorize: {e}")
- # The URL contained in the error will take the user to the authorization page
-```
-
-
-
-
-
-If a tool requires authorization, the agent will show a message like this:
-
-```bash
-[Authorize Gmail Access](https://accounts.google.com/o/oauth2/v2/auth?access_type=offline...)
-Once you have authorized access, I can retrieve your latest emails.
-```
-
-
-
-
-
-### Complete example
-
-Here's a complete example putting everything together:
-
-
-
-
-```python
-from agents import Agent, Runner
-from arcadepy import AsyncArcade
-
-from agents_arcade import get_arcade_tools
-from agents_arcade.errors import AuthorizationError
-
-
-async def main():
- client = AsyncArcade()
- tools = await get_arcade_tools(client, toolkits=["gmail"])
-
- google_agent = Agent(
- name="Google agent",
- instructions="You are a helpful assistant that can assist with Google API calls.",
- model="gpt-4o-mini",
- tools=tools,
- )
-
- try:
- result = await Runner.run(
- starting_agent=google_agent,
- input="What are my latest emails?",
- context={"user_id": "{arcade_user_id}"},
- )
- print("Final output:\n\n", result.final_output)
- except AuthorizationError as e:
- print("Please Login to Google:", e)
-
-
-if __name__ == "__main__":
- import asyncio
-
- asyncio.run(main())
-```
-
-
-
-
-
-Check out the complete working example in our [GitHub repository](https://github.com/ArcadeAI/arcade-ai/tree/main/examples/openai-agents-ts/src/index.ts).
-
-```javascript
-import Arcade from '@arcadeai/arcadejs';
-import { executeOrAuthorizeZodTool, toZod } from "@arcadeai/arcadejs/lib";
-import { Agent, run, tool } from '@openai/agents';
-
-// 1) Initialize Arcade client
-const client = new Arcade();
-
-// 2) Fetch Gmail MCP Server from Arcade and prepare tools for OpenAI Agents
-const googleToolkit = await client.tools.list({ toolkit: "gmail", limit: 30 });
-const tools = toZod({
- tools: googleToolkit.items,
- client,
- userId: "", // Replace this with your application's user ID (e.g. email address, UUID, etc.)
- executeFactory: executeOrAuthorizeZodTool,
-}).map(tool);
-
-// 3) Create a new agent with the Gmail MCP Server
-const googleAgent = new Agent({
- name: "Gmail agent",
- instructions: "You are a helpful assistant that can assist with Google API calls.",
- model: "gpt-4o-mini",
- tools
-});
-
-// 4) Run the agent
-const result = await run(googleAgent, "What are my latest emails?");
-
-// 5) Print the result
-console.log(result.finalOutput);
-```
-
-
-
-
-
-
-## Tips for selecting tools
-
-- **Relevance**: Pick only the tools you need. Avoid using all tools at once.
-- **User identification**: Always provide a unique and consistent `user_id` for each user. Use your internal or database user ID, not something entered by the user.
-
-## Next steps
-
-Now that you have integrated Arcade tools into your OpenAI Agents application, you can:
-
-- Experiment with different MCP Servers, such as "Github" or "LinkedIn"
-- Customize the agent's instructions for specific tasks
-- Try out multi-agent systems using different Arcade tools
-- Build your own custom tools with the Arcade Tool SDK
-
-Enjoy exploring Arcade and building powerful AI-enabled Python applications!
diff --git a/app/en/home/oai-agents/user-auth-interrupts/page.mdx b/app/en/home/oai-agents/user-auth-interrupts/page.mdx
deleted file mode 100644
index d76bc6b63..000000000
--- a/app/en/home/oai-agents/user-auth-interrupts/page.mdx
+++ /dev/null
@@ -1,442 +0,0 @@
----
-title: "Managing user authorization"
-description: "Handle tool authorization with Arcade and OpenAI Agents"
----
-
-import { Steps, Tabs, Callout } from "nextra/components";
-
-## User authorization with OpenAI Agents
-
-In this guide, you will learn how to handle user authorization for Arcade tools in your OpenAI Agents application. When a tool requires authorization, the agent will raise an `AuthorizationError` with a URL for the user to visit and grant permissions.
-
-
-
-### Prerequisites
-
-- [Obtain an Arcade API key](/home/api-keys)
-
-### Install the required packages
-
-Set up your environment with the following installations:
-
-
-
-
-```bash
-pip install agents-arcade arcadepy
-```
-
-
-
-
-
-```bash
-npm install @openai/agents @arcadeai/agents-arcade
-```
-
-
-
-
-
-### Configure your Arcade environment
-
-Make sure you have set your Arcade API key in the environment, or assign it directly in the code:
-
-> Need an Arcade API key? Visit the [Get an API key](/home/api-keys) page to create one.
-
-
-
-
-```python
-import os
-from arcadepy import AsyncArcade
-from agents import Agent, Runner
-from agents_arcade import get_arcade_tools
-from agents_arcade.errors import AuthorizationError
-
-# Set your API key
-os.environ["ARCADE_API_KEY"] = "YOUR_ARCADE_API_KEY"
-
-# Initialize the Arcade client
-client = AsyncArcade()
-```
-
-
-
-
-
-Add your API key to your environment variables:
-
-```bash
-# In your .env file
-ARCADE_API_KEY=YOUR_ARCADE_API_KEY
-```
-
-```javascript
-import Arcade from '@arcadeai/arcadejs';
-import { isAuthorizationRequiredError, toZod } from "@arcadeai/arcadejs/lib";
-import { Agent, run, tool } from '@openai/agents';
-
-const client = new Arcade();
-```
-
-
-
-
-### Fetch Arcade tools
-
-Get the tools you need for your agent. In this example, we'll use GitHub tools:
-
-
-
-
-```python
-# Get GitHub tools for this example
-tools = await get_arcade_tools(client, toolkits=["github"])
-
-# Create an agent with GitHub tools
-github_agent = Agent(
- name="GitHub agent",
- instructions="You are a helpful assistant that can assist with GitHub API calls.",
- model="gpt-4o-mini",
- tools=tools,
-)
-```
-
-
-
-
-
-```javascript
-const githubToolkit = await client.tools.list({ toolkit: "github", limit: 30 });
-const arcadeTools = toZod({
- tools: githubToolkit.items,
- client,
- userId: "", // Replace this with your application's user ID (e.g. email address, UUID, etc.)
-})
-```
-
-
-
-
-
-
-### Handle authorization errors
-
-
-
-
-When a user needs to authorize access to a tool, the agent will raise an `AuthorizationError`. You can handle it like this:
-
-```python
-try:
- result = await Runner.run(
- starting_agent=github_agent,
- input="Star the arcadeai/arcade-ai repo",
- # Pass a unique user_id for authentication
- context={"user_id": "{arcade_user_id}"},
- )
- print("Final output:\n\n", result.final_output)
-except AuthorizationError as e:
- # Display the authorization URL to the user
- print(f"Please Login to GitHub: {e}")
- # The error contains the authorization URL that the user should visit
-```
-
-
-
-
-
-Choose how to handle authorization errors based on your needs:
-
-**Default behavior (throws errors):**
-```javascript
-const arcadeTools = toZod({
- tools: githubToolkit.items,
- client,
- userId: "", // Replace with your user ID
-});
-```
-
-Use this when you want to handle authorization flow yourself with custom logic.
-
-**Auto-handle authorization (recommended):**
-```javascript
-import { executeOrAuthorizeZodTool } from "@arcadeai/arcadejs/lib";
-
-const arcadeTools = toZod({
- tools: githubToolkit.items,
- client,
- userId: "", // Replace with your user ID
- executeFactory: executeOrAuthorizeZodTool,
-});
-```
-
-This automatically returns authorization URLs instead of throwing errors.
-
-**Custom error handling:**
-
-```javascript
-import { isAuthorizationRequiredError } from "@arcadeai/arcadejs/lib";
-
-const tools = arcadeTools.map((arcadeTool) => {
- return tool({
- ...arcadeTool,
- errorFunction: async (_, error) => {
- if (error instanceof Error && isAuthorizationRequiredError(error)) {
- const response = await client.tools.authorize({
- tool_name: arcadeTool.name,
- user_id: "",
- });
- return `Please login to Google: ${response.url}`;
- }
- return "Error executing tool"
- }
- })
-});
-```
-
-
-
-
-
-### Wait for authorization completion
-
-You can also wait for the user to complete the authorization before continuing:
-
-
-
-
-```python
-from arcadepy import AsyncArcade
-import asyncio
-
-client = AsyncArcade()
-
-async def handle_auth_flow(auth_id):
- # Display a message to the user
- print("Please visit the authorization URL in your browser")
-
-
- # Wait for the user to authenticate
- await client.auth.wait_for_completion(auth_id)
-
- # Check if authorization was successful
- if await is_authorized(auth_id):
- print("Authorization successful! You can now use the tool.")
- return True
- else:
- print("Authorization failed or timed out.")
- return False
-
-# In your main function
-try:
- # Run agent code
- # ...
-except AuthorizationError as e:
- auth_id = e.auth_id
- if await handle_auth_flow(auth_id):
- # Try running the agent again
- result = await Runner.run(
- starting_agent=github_agent,
- input="Star the arcadeai/arcade-ai repo",
- context={"user_id": "{arcade_user_id}"},
- )
- print("Final output:\n\n", result.final_output)
-```
-
-
-
-
-
-To wait for authorization completion, follow this approach:
-
-1. Throw the error to the agent
-2. Catch and handle the error while waiting for completion
-
-
-
-```javascript
-const tools = arcadeTools.map((arcadeTool) => {
- return tool({
- ...arcadeTool,
- errorFunction: (_, error) => { throw error } // Throw the error to the agent for handling
- })
-});
-
-while (true) {
- try {
- const result = await run(googleAgent, "What are my latest emails?");
- console.log(result.finalOutput);
- } catch (error) {
- // Catch the authorization error and wait for completion
- if (error instanceof Error && isAuthorizationRequiredError(error)) {
- const response = await client.tools.authorize({
- tool_name: "Gmail_ListEmails",
- user_id: "",
- });
- if (response.status !== "completed") {
- console.log(`Please complete the authorization challenge in your browser: ${response.url}`);
- }
-
- // Wait for the authorization to complete
- await client.auth.waitForCompletion(response);
- console.log("Authorization completed, retrying...");
- }
- }
- }
-```
-
-
-
-
-
-
-
-### Complete example
-
-Here's a full example that demonstrates the authorization flow with waiting for authentication:
-
-
-
-
-```python
-from arcadepy.auth import wait_for_authorization_completion
-
-import time
-
-from agents import Agent, Runner
-from arcadepy import AsyncArcade
-
-from agents_arcade import get_arcade_tools
-from agents_arcade.errors import AuthorizationError
-
-
-async def main():
- client = AsyncArcade()
- # Use the "github" MCP Server for this example
- tools = await get_arcade_tools(client, toolkits=["github"])
-
- github_agent = Agent(
- name="GitHub agent",
- instructions="You are a helpful assistant that can assist with GitHub API calls.",
- model="gpt-4o-mini",
- tools=tools,
- )
-
- user_id = "{arcade_user_id}" # Make sure to use a unique user ID
-
- while True:
- try:
- result = await Runner.run(
- starting_agent=github_agent,
- input="Star the arcadeai/arcade-ai repo",
- # Pass the user_id for auth
- context={"user_id": user_id},
- )
- print("Final output:\n\n", result.final_output)
- break # Exit the loop if successful
-
- except AuthorizationError as e:
- auth_url = str(e)
- print(f"{auth_url}. Please authenticate to continue.")
-
- # Wait for the user to authenticate
- await client.auth.wait_for_completion(e.result.id)
-
-
-if __name__ == "__main__":
- import asyncio
-
- asyncio.run(main())
-```
-
-
-
-
-
-Check out the complete working example in our [GitHub repository](https://github.com/ArcadeAI/arcade-ai/tree/main/examples/openai-agents-ts/src/waitForCompletion.ts).
-
-```javascript
-import Arcade from '@arcadeai/arcadejs';
-import { isAuthorizationRequiredError, toZod } from "@arcadeai/arcadejs/lib";
-import { Agent, run, tool } from '@openai/agents';
-
-async function main() {
- // 1) Initialize Arcade client
- const client = new Arcade();
-
- // 2) Fetch Gmail MCP Server from Arcade and prepare tools for OpenAI Agents
- const googleToolkit = await client.tools.list({ toolkit: "gmail", limit: 30 });
- const tools = toZod({
- tools: googleToolkit.items,
- client,
- userId: "", // Replace this with your application's user ID (e.g. email address, UUID, etc.)
- }).map(tool);
-
- // 3) Create a new agent with the Gmail MCP Server
- const googleAgent = new Agent({
- name: "Gmail agent",
- instructions: "You are a helpful assistant that can assist with Google API calls.",
- model: "gpt-4o-mini",
- tools
- });
-
- // 4) Run the agent, if authorization is required, wait for it to complete and retry
- while (true) {
- try {
- const result = await run(googleAgent, "What are my latest emails?");
- console.log(result.finalOutput);
- break; // Exit the loop if the result is successful
- } catch (error) {
- if (error instanceof Error && isAuthorizationRequiredError(error)) {
- const response = await client.tools.authorize({
- tool_name: "Gmail_ListEmails",
- user_id: "",
- });
- if (response.status !== "completed") {
- console.log(`Please complete the authorization challenge in your browser: ${response.url}`);
- }
-
- // Wait for the authorization to complete
- await client.auth.waitForCompletion(response);
- console.log("Authorization completed, retrying...");
- }
- }
- }
-}
-
-main();
-```
-
-
-This example handles the authentication flow by:
-
-1. Attempting to run the agent
-2. Catching any AuthorizationError
-3. Open the authentication URL in a browser
-4. Waiting for the user to complete authentication
-5. Retrying the operation after a wait period
-
-
-
-
-## Authentication persistence
-
-Once a user authorizes with an auth provider, Arcade will remember the authorization for that specific user_id and MCP Server. You don't need to re-authorize each time you run the agent.
-
-Key points to remember:
-
-- Always use a consistent and unique `user_id` for each user
-- Store the `user_id` securely in your application
-- Different MCP Servers require separate authorization flows
-- Authorization tokens are managed by Arcade, not your application
-
-## Next steps
-
-- Build a user interface to handle authorization flows smoothly
-- Explore other Arcade MCP Servers like Google, LinkedIn, or X
-- Create multi-step workflows with multiple tools and authorizations
-- Learn to build your own custom tools with the Arcade Tool SDK
-
-By handling Arcade's authorization flow correctly, you can build AI-driven applications that securely integrate with various services while respecting user permissions. Have fun exploring Arcade!
diff --git a/app/en/home/observability/_meta.tsx b/app/en/home/observability/_meta.tsx
new file mode 100644
index 000000000..6ef2a0bed
--- /dev/null
+++ b/app/en/home/observability/_meta.tsx
@@ -0,0 +1,4 @@
+export default {
+ index: "Overview",
+ platforms: "Platforms",
+};
diff --git a/app/en/home/observability/page.mdx b/app/en/home/observability/page.mdx
new file mode 100644
index 000000000..6df5c9f48
--- /dev/null
+++ b/app/en/home/observability/page.mdx
@@ -0,0 +1,22 @@
+# Observability
+
+Learn how to monitor, trace, and gain insights into your Arcade-powered AI agents and tool executions.
+
+## Overview
+
+Observability is crucial for understanding the behavior of your AI agents, monitoring tool performance, and debugging issues in production. Arcade provides comprehensive observability features that help you track agent actions, tool executions, and system performance.
+
+## Key Features
+
+- **Tool Execution Tracing**: Monitor every tool call made by your agents
+- **Performance Metrics**: Track response times, success rates, and error patterns
+- **Agent Behavior Insights**: Understand how your agents make decisions and use tools
+- **Integration Support**: Connect with popular observability platforms
+
+## Getting Started
+
+Choose from our supported observability platforms or implement custom monitoring solutions using Arcade's observability APIs.
+
+## Next Steps
+
+Explore the platforms section to learn how to integrate Arcade with your preferred observability tools.
\ No newline at end of file
diff --git a/app/en/home/observability/platforms/_meta.tsx b/app/en/home/observability/platforms/_meta.tsx
new file mode 100644
index 000000000..22b2653f5
--- /dev/null
+++ b/app/en/home/observability/platforms/_meta.tsx
@@ -0,0 +1,4 @@
+export default {
+ "quickstarts-placeholder":
+ "Placeholder for Quickstarts of various observability platforms",
+};
diff --git a/app/en/home/observability/platforms/quickstarts-placeholder/page.mdx b/app/en/home/observability/platforms/quickstarts-placeholder/page.mdx
new file mode 100644
index 000000000..6f3cdb56d
--- /dev/null
+++ b/app/en/home/observability/platforms/quickstarts-placeholder/page.mdx
@@ -0,0 +1,7 @@
+# Placeholder for Quickstarts of various observability platforms
+
+Documentation coming soon.
+
+## Overview
+
+This section will contain detailed information about integrating Arcade with various observability platforms.
\ No newline at end of file
diff --git a/app/en/home/python-quickstart/page.mdx b/app/en/home/python-quickstart/page.mdx
new file mode 100644
index 000000000..04ef6b4c2
--- /dev/null
+++ b/app/en/home/python-quickstart/page.mdx
@@ -0,0 +1,38 @@
+# Python Quickstart
+
+This is a placeholder page for the Python quickstart guide.
+
+## Overview
+
+Get started with Arcade tools in Python applications quickly and easily.
+
+## Prerequisites
+
+- Python 3.8 or higher
+- Arcade API key
+- Virtual environment (recommended)
+
+## Installation
+
+```bash
+pip install arcade-ai
+```
+
+## Quick Setup
+
+```python
+import arcade
+
+# Initialize the client
+client = arcade.Arcade(api_key="your-api-key")
+
+# Call a tool
+result = client.tools.call("example-tool", {"param": "value"})
+print(result)
+```
+
+## Next Steps
+
+- [Tool Calling Introduction](/en/home/tool-calling-intro)
+- [Authorized Tool Calling](/en/home/authorized-tool-calling)
+- [Error Handling](/en/home/error-handling)
\ No newline at end of file
diff --git a/app/en/home/quickstart/page.mdx b/app/en/home/quickstart/page.mdx
deleted file mode 100644
index 212aba924..000000000
--- a/app/en/home/quickstart/page.mdx
+++ /dev/null
@@ -1,206 +0,0 @@
----
-title: "Start using Arcade's Hosted Tools"
-description: "Learn how to get started with Arcade's Hosted Tools"
----
-
-import { Steps, Tabs, Callout } from "nextra/components";
-import { SignupLink } from "@/app/_components/analytics";
-
-# Arcade's Hosted Tools Quickstart
-
-Arcade gives your AI agents the power to act. With Arcade's Hosted Tools, your AI can send Gmail, update Notion, message in Slack, and more.
-
-
-
-
-Install and use the Arcade client to call Arcade Hosted Tools.
-
-
-
-
-
-- An Arcade account
-- An [Arcade API key](/home/api-keys)
-- The [`uv` package manager](https://docs.astral.sh/uv/getting-started/installation/)
-
-
-
-
-
-- Install the Arcade client
-- Execute your first tool using the Arcade client
-- Authorize a tool to star a GitHub repository on your behalf
-
-
-
-
-
-
-### Install the Arcade client
-
-
-
-
- In your terminal, run the following command to install the Python client package `arcadepy`:
-
-```bash
-uv pip install arcadepy
-```
-
-
-
-
- In your terminal, run the following command to install the JavaScript client package `@arcadeai/arcadejs`:
-
-```bash
-npm install @arcadeai/arcadejs
-```
-
-
-
-
-
-### Instantiate and use the client
-
-
-
-
-
-Create a new script called `example.py`:
-
-```python filename="example.py"
-from arcadepy import Arcade
-
-# You can also set the `ARCADE_API_KEY` environment variable instead of passing it as a parameter.
-
-client = Arcade(api_key="{arcade_api_key}")
-
-# Arcade needs a unique identifier for your application user (this could be an email address, a UUID, etc).
-
-# In this example, use the email you used to sign up for Arcade.dev:
-
-user_id = "{arcade_user_id}"
-
-# Let's use the `Math.Sqrt` tool from the Arcade Math MCP Server to get the square root of a number.
-
-response = client.tools.execute(
- tool_name="Math.Sqrt",
- input={"a": '625'},
- user_id=user_id,
-)
-
-print(f"The square root of 625 is {response.output.value}")
-
-# Now, let's use a tool that requires authentication to star a GitHub repository
-
-auth_response = client.tools.authorize(
-tool_name="GitHub.SetStarred",
-user_id=user_id,
-)
-
-if auth_response.status != "completed":
- print(f"Click this link to authorize: `{auth_response.url}`. The process will continue once you have authorized the app." ) # Wait for the user to authorize the app
- client.auth.wait_for_completion(auth_response.id);
-
-response = client.tools.execute(
- tool_name="GitHub.SetStarred",
- input={
- "owner": "ArcadeAI",
- "name": "arcade-mcp",
- "starred": True,
- },
- user_id=user_id,
-)
-
-print(response.output.value)
-
-```
-
-
-
-
-
-Create a new script called `example.mjs`:
-
-```javascript filename="example.mjs"
-import Arcade from "@arcadeai/arcadejs";
-
-// You can also set the `ARCADE_API_KEY` environment variable instead of passing it as a parameter.
-const client = new Arcade({
- apiKey: "{arcade_api_key}",
-});
-
-// Arcade needs a unique identifier for your application user (this could be an email address, a UUID, etc).
-// In this example, use the email you used to sign up for Arcade.dev:
-let userId = "{arcade_user_id}";
-
-// Let's use the `Math.Sqrt` tool from the Arcade Math MCP Server to get the square root of a number.
-const response_sqrt = await client.tools.execute({
- tool_name: "Math.Sqrt",
- input: { a: "625" },
- user_id: userId,
-});
-
-console.log(response_sqrt.output.value);
-
-// Now, let's use a tool that requires authentication
-
-const authResponse = await client.tools.authorize({
- tool_name: "GitHub.SetStarred",
- user_id: userId,
-});
-
-if (authResponse.status !== "completed") {
- console.log(
- `Click this link to authorize: \`${authResponse.url}\`. The process will continue once you have authorized the app.`
- );
- // Wait for the user to authorize the app
- await client.auth.waitForCompletion(authResponse.id);
-}
-
-const response_github = await client.tools.execute({
- tool_name: "GitHub.SetStarred",
- input: {
- owner: "ArcadeAI",
- name: "arcade-mcp",
- starred: true,
- },
- user_id: userId,
-});
-
-console.log(response_github.output.value);
-```
-
-
-
-
-
-### Run the code
-
-
-
-
-
- ```bash
- uv run example.py
- > The square root of 625 is 25
- > Successfully starred the repository ArcadeAI/arcade-mcp
- ```
-
-
-
-
- ```bash
- node example.mjs
- > The square root of 625 is 25
- > Successfully starred the repository ArcadeAI/arcade-mcp
- ```
-
-
-
-
-
-
-## Next Steps
-
-In this simple example, we call the tool methods directly. In your real applications and agents, you'll likely be letting the LLM decide which tools to call - learn more about using Arcade with Frameworks in the [Frameworks](/home/langchain/use-arcade-tools) section, or [how to build your own tools](/home/build-tools/create-a-mcp-server).
diff --git a/app/en/home/quickstarts/_meta.tsx b/app/en/home/quickstarts/_meta.tsx
new file mode 100644
index 000000000..844ff782e
--- /dev/null
+++ b/app/en/home/quickstarts/_meta.tsx
@@ -0,0 +1,4 @@
+export default {
+ "call-tool-easy": "Call a tool in your app/agent",
+ "call-tool-personal-agent": "Call a tool in your IDE/MCP Client",
+};
diff --git a/app/en/home/quickstarts/call-tool-easy/page.mdx b/app/en/home/quickstarts/call-tool-easy/page.mdx
new file mode 100644
index 000000000..b041167f0
--- /dev/null
+++ b/app/en/home/quickstarts/call-tool-easy/page.mdx
@@ -0,0 +1,8 @@
+---
+title: "Call a tool in your agent"
+description: "The simplest way to call an Arcade tool in your agent"
+---
+
+# Call a tool in your agent
+
+Coming soon!
\ No newline at end of file
diff --git a/app/en/home/quickstarts/call-tool-personal-agent/page.mdx b/app/en/home/quickstarts/call-tool-personal-agent/page.mdx
new file mode 100644
index 000000000..fddd5f371
--- /dev/null
+++ b/app/en/home/quickstarts/call-tool-personal-agent/page.mdx
@@ -0,0 +1,25 @@
+# Call a tool from your personal agent
+
+Learn how to integrate Arcade tools with your personal AI agent.
+
+## Overview
+
+Learn how to call tools in 3rd party agents, apps, or IDEs using the MCP Gateway.
+
+## Prerequisites
+
+- Arcade API key
+- Supported MCP client
+
+## Setup Steps
+
+1. Configure your MCP Gateway
+2. Connect to your client application
+3. Test tool calling functionality
+
+## Supported Clients
+
+- Cursor
+- Claude Desktop
+- Visual Studio Code
+- Other MCP-compatible applications
\ No newline at end of file
diff --git a/app/en/home/sample-agents/page.mdx b/app/en/home/sample-agents/page.mdx
new file mode 100644
index 000000000..454b662a9
--- /dev/null
+++ b/app/en/home/sample-agents/page.mdx
@@ -0,0 +1,26 @@
+# Sample Agents with Tool Calling
+
+This is a placeholder page for sample agents with tool calling examples.
+
+## Overview
+
+Explore a suite of example agents you can duplicate and build off of for your custom applications.
+
+## Available Examples
+
+- Customer support agent
+- Data analysis agent
+- Content creation agent
+- Task automation agent
+
+## Getting Started
+
+Each sample agent includes:
+- Complete source code
+- Setup instructions
+- Tool configuration
+- Deployment guidelines
+
+## Template Repository
+
+Find all sample agents in our GitHub repository with ready-to-deploy examples.
\ No newline at end of file
diff --git a/app/en/home/security-section/_meta.tsx b/app/en/home/security-section/_meta.tsx
new file mode 100644
index 000000000..216e236f4
--- /dev/null
+++ b/app/en/home/security-section/_meta.tsx
@@ -0,0 +1,5 @@
+export default {
+ "platform-security": "Platform security",
+ "enterprise-sso": "Enterprise single sign on",
+ "rbac-config": "Configure role-based access control for your organization",
+};
diff --git a/app/en/home/security-section/enterprise-sso/page.mdx b/app/en/home/security-section/enterprise-sso/page.mdx
new file mode 100644
index 000000000..009719dab
--- /dev/null
+++ b/app/en/home/security-section/enterprise-sso/page.mdx
@@ -0,0 +1,8 @@
+---
+title: "Enterprise Single Sign On"
+description: "Learn about enterprise SSO integration"
+---
+
+# Enterprise Single Sign On
+
+Coming soon!
diff --git a/app/en/home/security-section/platform-security/page.mdx b/app/en/home/security-section/platform-security/page.mdx
new file mode 100644
index 000000000..0a0971791
--- /dev/null
+++ b/app/en/home/security-section/platform-security/page.mdx
@@ -0,0 +1,8 @@
+---
+title: "Platform Security"
+description: "Learn about Arcade platform security"
+---
+
+# Platform Security
+
+Coming soon!
\ No newline at end of file
diff --git a/app/en/home/security-section/rbac-config/page.mdx b/app/en/home/security-section/rbac-config/page.mdx
new file mode 100644
index 000000000..48c351e9b
--- /dev/null
+++ b/app/en/home/security-section/rbac-config/page.mdx
@@ -0,0 +1,8 @@
+---
+title: "Configuring Role Based Access Control for your organization"
+description: "Learn how to configure RBAC for your organization"
+---
+
+# Configuring Role Based Access Control for your organization
+
+Coming soon!
diff --git a/app/en/home/security/page.mdx b/app/en/home/security/page.mdx
index 1bed172bd..7621354ee 100644
--- a/app/en/home/security/page.mdx
+++ b/app/en/home/security/page.mdx
@@ -1,49 +1,7 @@
----
-title: "Security Research Program"
-description: "Report security vulnerabilities and help us build safe and reliable tools"
----
+# Security
-# Security Research Program
+Security best practices for Arcade applications.
-At Arcade, security is fundamental to our mission of building safe and reliable tools. We recognize that the security research community plays a valuable role in identifying potential vulnerabilities.
-
-## Scope
-
-Our program covers security issues in:
-* Arcade production services and APIs
-* Agent authentication and authorization mechanisms
-* Data handling and storage systems
-* Published open-source components
-
-## What we're looking for
-
-We're interested in reports about:
-* Authentication or authorization bypasses
-* Data exposure or leakage
-* Injection vulnerabilities
-* Logic flaws affecting agent behavior
-* Issues that could compromise user data or agent integrity
-
-## Reporting process
-
-Please email [security@arcade.dev](mailto:security@arcade.dev) with:
-* A clear description of the issue
-* Steps to reproduce
-* Potential impact assessment
-* Any relevant proof-of-concept code (please be responsible)
-
-We'll acknowledge receipt within 72 hours and aim to provide an initial assessment within one week.
-
-## Guidelines
-
-* Please allow us reasonable time to address issues before public disclosure
-* Avoid automated scanning that could impact service availability
-* Do not access or modify other users' data
-* Keep any discovered vulnerabilities confidential until resolved
-
-## Recognition
-
-While we're a small team with limited resources, we appreciate the effort researchers put into improving our security. We'll credit researchers (with permission) in our security updates and may provide modest rewards for significant findings on a case-by-case basis.
-
-For questions about this program, please contact [security@arcade.dev](mailto:security@arcade.dev).
+## Overview
+Learn about security considerations and best practices.
diff --git a/app/en/home/serve-tools/_meta.tsx b/app/en/home/serve-tools/_meta.tsx
deleted file mode 100644
index c7e61f707..000000000
--- a/app/en/home/serve-tools/_meta.tsx
+++ /dev/null
@@ -1,4 +0,0 @@
-export default {
- "arcade-deploy": "Arcade Deploy",
- "securing-arcade-mcp": "Securing Arcade MCP",
-};
diff --git a/app/en/home/serve-tools/securing-arcade-mcp/page.mdx b/app/en/home/serve-tools/securing-arcade-mcp/page.mdx
deleted file mode 100644
index 4b3a8a287..000000000
--- a/app/en/home/serve-tools/securing-arcade-mcp/page.mdx
+++ /dev/null
@@ -1,15 +0,0 @@
-# Securing Arcade MCP Deployments
-
-You may have noticed that when you connected to the MCP serer you created with `arcade-mcp`, you could immediately call your tools from local MCP Clients and agents, like Claude and Cursor. This is because the `arcade-mcp` server is *not* secured by any mechanism by default. Most use-cases for MCP servers today are local development or local to a single machine, and we optimize for that use-case.
-
-However, you can secure your MCP server by deploying it to Arcade (available today) or using OAuth (coming soon).
-
-## Arcade Deploy
-When you `arcade deploy` your MCP server, it will be secured behind the Arcade platform.
-
-Under the hood, we disable the MCP routes provided by `arcade-mcp`, and use the Arcade Engine as a gateway for your MCP server, which has a number of additional features. Arcade will create a randomized secure secret for your MCP server (via the `ARCADE_WORKER_SECRET` environment variable) so that your server is protected from unauthorized access, as well as being isolated from direct access from outside of the Arcade platform. Servers managed by Arcade (servers that are `arcade deploy`ed) serve `/worker` endpoints that are protected by this secret. The worker endpoints are `worker/health`, `/worker/tools`, and `/worker/tools/invoke`. The health endpoint is not protected by this secret, but the listing tools and tool invocations are. You can explore this locally by setting the same environment variable in your locally.
-
-Learn more about how to deploy your MCP server to Arcade [here](/home/serve-tools/arcade-deploy).
-
-## OAuth (Coming soon)
-Coming soon, you will be able to secure your MCP server's `/mcp` endpoints with a OAuth Authorization Server (AS) - either using Dynamic Client Registration (DCR) or Client ID Metadata Documents (CIMD). Learn more about how MCP integrates with OAuth [here](https://blog.modelcontextprotocol.io/posts/client_registration/).
diff --git a/app/en/home/setup/_meta.tsx b/app/en/home/setup/_meta.tsx
new file mode 100644
index 000000000..d624b2d59
--- /dev/null
+++ b/app/en/home/setup/_meta.tsx
@@ -0,0 +1,4 @@
+export default {
+ "api-key": "Get an API key",
+ "connect-arcade-docs": "Connect Arcade docs to your IDE",
+};
diff --git a/app/en/home/setup/api-key/page.mdx b/app/en/home/setup/api-key/page.mdx
new file mode 100644
index 000000000..b1c436f3e
--- /dev/null
+++ b/app/en/home/setup/api-key/page.mdx
@@ -0,0 +1,108 @@
+---
+title: "Getting Your API Key"
+description: "Learn how to obtain and manage your Arcade API key"
+---
+
+import { Steps, Tabs, Callout } from "nextra/components";
+import { SignupLink } from "@/app/_components/analytics";
+
+# Getting Your API Key
+
+Before you begin, you'll need an Arcade account - if you haven't created one yet, you can sign up here. Once you have an account, you can generate API keys through either our dashboard or CLI.
+
+
+
+
+
+### Using the Dashboard
+
+
+
+
+
+
+### Navigate to API Keys page
+Visit the [API Keys page](https://api.arcade.dev/dashboard/api-keys) in Arcade Dashboard.
+
+### Create a new API key
+
+1. Click the `Create API Key` button in the top right
+2. Enter a descriptive name to help identify your key
+3. Click `Create API Key` to generate your key
+
+### Save your API key securely
+
+1. Copy your API key immediately - it will only be shown once
+2. Store it securely
+3. You can always generate new keys if needed
+
+
+
+
+
+
+
+### Using the CLI
+
+
+
+### Install and login
+
+1. Install the Arcade CLI:
+
+
+
+
+```bash
+uv tool install arcade-mcp
+```
+
+
+This will install the Arcade CLI as a [uv tool](https://docs.astral.sh/uv/guides/tools/), making it available system wide.
+
+
+
+
+```bash
+pip install arcade-mcp
+```
+
+
+
+2. Start the login process:
+
+```bash
+arcade login
+```
+
+### Complete setup
+
+The CLI will automatically:
+
+- Print your API key to the console
+- Save your credentials to `~/.arcade/credentials.yaml`
+
+
+
+
+
+
+
+ API keys are administrator credentials. Anyone who has your API key can make
+ requests to Arcade as you. Always store your API keys in a safe place, such as
+ system environment variables, and never commit them to version control, share
+ them publicly, or use them in browser or frontend code.
+
+## Next Steps
+
+Once you have your API key, you can:
+
+- [Start using tools](/home/quickstart)
+- [Create custom tools](/home/build-tools/create-a-mcp-server)
\ No newline at end of file
diff --git a/app/en/home/agentic-development/page.mdx b/app/en/home/setup/connect-arcade-docs/page.mdx
similarity index 96%
rename from app/en/home/agentic-development/page.mdx
rename to app/en/home/setup/connect-arcade-docs/page.mdx
index 40845e0e1..d575d5d7c 100644
--- a/app/en/home/agentic-development/page.mdx
+++ b/app/en/home/setup/connect-arcade-docs/page.mdx
@@ -23,4 +23,4 @@ Context7 is an MCP server designed to provide Large Language Models (LLMs) and A
To use Context7, you first need to add the [Context7 MCP server](https://github.com/upstash/context7) to your editor, and then select the [`arcadeai/docs` project](https://context7.com/arcadeai/docs).
-Learn more about Context7 [here](https://context7.com/).
+Learn more about Context7 [here](https://context7.com/).
\ No newline at end of file
diff --git a/app/en/home/sharing-with-end-users/_meta.tsx b/app/en/home/sharing-with-end-users/_meta.tsx
new file mode 100644
index 000000000..4c9160fc1
--- /dev/null
+++ b/app/en/home/sharing-with-end-users/_meta.tsx
@@ -0,0 +1,5 @@
+export default {
+ "multi-user-auth": "Set up secure multi-user auth",
+ "configure-oauth-provider": "Configure an OAuth provider",
+ "brand-auth-flow": "Brand your Auth flow",
+};
diff --git a/app/en/home/sharing-with-end-users/brand-auth-flow/page.mdx b/app/en/home/sharing-with-end-users/brand-auth-flow/page.mdx
new file mode 100644
index 000000000..ed45d0b03
--- /dev/null
+++ b/app/en/home/sharing-with-end-users/brand-auth-flow/page.mdx
@@ -0,0 +1,3 @@
+# Brand your Auth flow
+
+Coming soon!
\ No newline at end of file
diff --git a/app/en/home/sharing-with-end-users/configure-oauth-provider/page.mdx b/app/en/home/sharing-with-end-users/configure-oauth-provider/page.mdx
new file mode 100644
index 000000000..2e88002de
--- /dev/null
+++ b/app/en/home/sharing-with-end-users/configure-oauth-provider/page.mdx
@@ -0,0 +1,27 @@
+# Configure an OAuth provider
+
+Learn how to configure OAuth providers for your user-facing agents to enable secure authentication with external services.
+
+## Overview
+
+When building user-facing agents, you need to configure OAuth providers to allow your users to securely connect their accounts with third-party services. This enables your agents to perform actions on behalf of your users while maintaining proper authorization and security.
+
+## Key Concepts
+
+- **OAuth Provider Configuration**: Set up the connection between your application and external services
+- **User Consent**: Enable users to grant permissions to your agents
+- **Token Management**: Handle access tokens and refresh tokens securely
+- **Scope Management**: Request appropriate permissions for your use case
+
+## Getting Started
+
+Configure OAuth providers through the Arcade Dashboard or programmatically via the Arcade API to enable your agents to access external services with user authorization.
+
+## Next Steps
+
+- Set up your first OAuth provider in the Dashboard
+- Configure user consent flows
+- Test the authentication process
+- Deploy your user-facing agent
+
+Documentation coming soon.
\ No newline at end of file
diff --git a/app/en/home/sharing-with-end-users/multi-user-auth/page.mdx b/app/en/home/sharing-with-end-users/multi-user-auth/page.mdx
new file mode 100644
index 000000000..0fa8e76dc
--- /dev/null
+++ b/app/en/home/sharing-with-end-users/multi-user-auth/page.mdx
@@ -0,0 +1,8 @@
+---
+title: "Set up secure multi-user auth"
+description: "Learn how to set up secure multi-user authentication for your application"
+---
+
+# Set up secure multi-user auth
+
+Coming soon!
diff --git a/app/en/home/tool-calling-intro/page.mdx b/app/en/home/tool-calling-intro/page.mdx
new file mode 100644
index 000000000..749e2f6f9
--- /dev/null
+++ b/app/en/home/tool-calling-intro/page.mdx
@@ -0,0 +1,31 @@
+# Tool Calling Introduction
+
+This is a placeholder page for an introduction to tool calling.
+
+## Overview
+
+Learn the fundamentals of tool calling with Arcade and how it enhances AI applications.
+
+## What is Tool Calling?
+
+Tool calling allows AI models to interact with external systems and APIs to perform actions beyond text generation.
+
+## Key Concepts
+
+- **Tools**: Functions that can be called by AI models
+- **Schemas**: Descriptions of tool parameters and return values
+- **Authorization**: Managing access to authenticated tools
+- **Context**: Runtime data passed to tools
+
+## Benefits
+
+- Extend AI capabilities beyond text
+- Connect to real-world systems
+- Perform actions on behalf of users
+- Access live data and services
+
+## Next Steps
+
+- [Error Handling](/en/home/error-handling)
+- [Tool Formats](/en/home/tool-formats)
+- [Authorized Tool Calling](/en/home/authorized-tool-calling)
\ No newline at end of file
diff --git a/app/en/home/tools/page.mdx b/app/en/home/tools/page.mdx
new file mode 100644
index 000000000..db1f4ea69
--- /dev/null
+++ b/app/en/home/tools/page.mdx
@@ -0,0 +1,35 @@
+# Tools
+
+Arcade provides a comprehensive ecosystem for AI tools that enable your agents to take real-world actions. Whether you need pre-built integrations or want to create custom functionality, Arcade has you covered.
+
+## Explore Our Tool Catalog
+
+Discover hundreds of ready-to-use tools for popular services like Gmail, Slack, GitHub, and more. Our catalog contains production-ready MCP servers that handle authentication, permissions, and API integrations seamlessly.
+
+[Browse Tool Catalog →](/mcp-servers)
+
+## Create Your Own Tools
+
+Build custom tools tailored to your specific needs using our powerful development framework. Create MCP servers, define tool schemas, and deploy them to production with ease.
+
+[Learn to Build Tools →](/home/creating-tools/tool-basics/build-mcp-server)
+
+## Contribute to the Catalog
+
+Share your tools with the Arcade community and help expand our ecosystem. Submit your MCP servers to make them available to developers worldwide.
+
+[Add Your Tools to the Catalog →](/home/creating-tools/new-functionality/custom-toolkit)
+
+## Why Choose Arcade Tools?
+
+- **Authentication Built-in**: OAuth flows and user permissions handled automatically
+- **Production Ready**: Tested, documented, and maintained by our team
+- **Universal Compatibility**: Works with any LLM or agent framework via MCP
+- **Scalable Architecture**: Tools run independently and scale based on demand
+
+## Getting Started
+
+1. **Explore**: Browse our catalog to find tools for your use case
+2. **Integrate**: Use our client libraries to connect tools to your agents
+3. **Customize**: Create your own tools when you need specific functionality
+4. **Share**: Contribute back to the community by adding your tools to our catalog
\ No newline at end of file
diff --git a/app/en/home/turn-api-to-mcp/page.mdx b/app/en/home/turn-api-to-mcp/page.mdx
new file mode 100644
index 000000000..9e25c3671
--- /dev/null
+++ b/app/en/home/turn-api-to-mcp/page.mdx
@@ -0,0 +1,3 @@
+# Turn an external API into a MCP Server
+
+Transform external APIs into MCP servers for use in agents.
\ No newline at end of file
diff --git a/app/en/home/use-tools/_meta.tsx b/app/en/home/use-tools/_meta.tsx
deleted file mode 100644
index 7661d8b0b..000000000
--- a/app/en/home/use-tools/_meta.tsx
+++ /dev/null
@@ -1,8 +0,0 @@
-import type { MetaRecord } from "nextra";
-
-export default {
- "tools-overview": "Introduction",
- "get-tool-definitions": "Tool formats",
- "types-of-tools": "Types of tools",
- "error-handling": "Error handling",
-} satisfies MetaRecord;
diff --git a/app/en/home/vercelai/_meta.tsx b/app/en/home/vercelai/_meta.tsx
deleted file mode 100644
index 6305a7f2b..000000000
--- a/app/en/home/vercelai/_meta.tsx
+++ /dev/null
@@ -1,3 +0,0 @@
-export default {
- "using-arcade-tools": "Using Arcade tools",
-};
diff --git a/app/en/home/what-is-agent/_meta.tsx b/app/en/home/what-is-agent/_meta.tsx
new file mode 100644
index 000000000..5ace1f9a3
--- /dev/null
+++ b/app/en/home/what-is-agent/_meta.tsx
@@ -0,0 +1,4 @@
+export default {
+ "why-agents-call-tools": "Why and how do agents call tools",
+ "intro-to-tag": "Intro to TAG",
+};
diff --git a/app/en/home/what-is-agent/intro-to-tag/page.mdx b/app/en/home/what-is-agent/intro-to-tag/page.mdx
new file mode 100644
index 000000000..2229639cf
--- /dev/null
+++ b/app/en/home/what-is-agent/intro-to-tag/page.mdx
@@ -0,0 +1,3 @@
+# Intro to TAG
+
+Coming soon.
\ No newline at end of file
diff --git a/app/en/home/what-is-agent/why-agents-call-tools/page.mdx b/app/en/home/what-is-agent/why-agents-call-tools/page.mdx
new file mode 100644
index 000000000..40df4c774
--- /dev/null
+++ b/app/en/home/what-is-agent/why-agents-call-tools/page.mdx
@@ -0,0 +1,3 @@
+# Why and how do agents call tools?
+
+Coming soon.
\ No newline at end of file
diff --git a/app/en/home/why-agents-call-tools/page.mdx b/app/en/home/why-agents-call-tools/page.mdx
new file mode 100644
index 000000000..7efa78eb0
--- /dev/null
+++ b/app/en/home/why-agents-call-tools/page.mdx
@@ -0,0 +1,7 @@
+# Why and how do agents call tools?
+
+Learn why agents need tools and how tool calling works.
+
+## Overview
+
+Understand the relationship between agents and tools.
diff --git a/app/en/mcp-servers/components/filters-bar.tsx b/app/en/mcp-servers/components/filters-bar.tsx
index 9d41b5640..9fc7024f2 100644
--- a/app/en/mcp-servers/components/filters-bar.tsx
+++ b/app/en/mcp-servers/components/filters-bar.tsx
@@ -54,7 +54,7 @@ export function FiltersBar({ resultsCount }: FiltersBarProps) {
-
-
-
-When you authorize a tool, you'll be prompted to sign in to your Arcade.dev account. If you are already signed in (to the Arcade Dashboard, for example), this verification will succeed silently.
-
-The Arcade.dev user verifier helps keep your auth flows secure while you are building and testing your agent or app. When you're ready to share your work with others, implement a [custom user verifier](#build-a-custom-user-verifier) so your users don't need to sign in to Arcade.dev.
-
-