diff --git a/app/en/get-started/agent-frameworks/langchain/_meta.tsx b/app/en/get-started/agent-frameworks/langchain/_meta.tsx
index a2708a562..070d90407 100644
--- a/app/en/get-started/agent-frameworks/langchain/_meta.tsx
+++ b/app/en/get-started/agent-frameworks/langchain/_meta.tsx
@@ -1,5 +1,4 @@
export default {
- "use-arcade-tools": "Using Arcade tools",
- "user-auth-interrupts": "User authorization",
"auth-langchain-tools": "Authorizing existing tools",
+ "use-arcade-with-langchain": "Setup Arcade with LangChain",
};
diff --git a/app/en/get-started/agent-frameworks/langchain/use-arcade-tools/page.mdx b/app/en/get-started/agent-frameworks/langchain/use-arcade-tools/page.mdx
deleted file mode 100644
index a16ccd5b4..000000000
--- a/app/en/get-started/agent-frameworks/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](/get-started/setup/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](/get-started/setup/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](/guides/tool-calling/custom-apps/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/get-started/agent-frameworks/langchain/use-arcade-with-langchain/page.mdx b/app/en/get-started/agent-frameworks/langchain/use-arcade-with-langchain/page.mdx
index 16f73cb26..fee9dc3d1 100644
--- a/app/en/get-started/agent-frameworks/langchain/use-arcade-with-langchain/page.mdx
+++ b/app/en/get-started/agent-frameworks/langchain/use-arcade-with-langchain/page.mdx
@@ -461,6 +461,8 @@ You should see the agent responding to your prompts like any model, as well as h
## Example code
+
+**main.ts** (full file)
```ts filename="main.ts"
"use strict";
import { Arcade } from "@arcadeai/arcadejs";
@@ -737,3 +739,4 @@ async function main() {
// Run the main function
main().catch((err) => console.error(err));
```
+
diff --git a/app/en/get-started/agent-frameworks/langchain/user-auth-interrupts/page.mdx b/app/en/get-started/agent-frameworks/langchain/user-auth-interrupts/page.mdx
deleted file mode 100644
index d52678880..000000000
--- a/app/en/get-started/agent-frameworks/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](/get-started/setup/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](/get-started/setup/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/next.config.ts b/next.config.ts
index 784d55f97..ad865469f 100644
--- a/next.config.ts
+++ b/next.config.ts
@@ -23,6 +23,21 @@ const nextConfig: NextConfig = withLlmsTxt({
withNextra({
async redirects() {
return [
+ // Removed LangChain old stuff
+ {
+ source:
+ "/:locale/get-started/agent-frameworks/langchain/use-arcade-tools",
+ destination:
+ "/:locale/get-started/agent-frameworks/langchain/use-arcade-with-langchain",
+ permanent: true,
+ },
+ {
+ source:
+ "/:locale/get-started/agent-frameworks/langchain/user-auth-interrupts",
+ destination:
+ "/:locale/get-started/agent-frameworks/langchain/use-arcade-with-langchain",
+ permanent: true,
+ },
// Moved from guides to get-started
{
source:
@@ -35,13 +50,26 @@ const nextConfig: NextConfig = withLlmsTxt({
{
source: "/:locale/home/langchain/use-arcade-tools",
destination:
- "/:locale/get-started/agent-frameworks/langchain/use-arcade-tools",
+ "/:locale/get-started/agent-frameworks/langchain/use-arcade-with-langchain",
+ permanent: true,
+ },
+ {
+ source: "/:locale/guides/agent-frameworks/langchain/use-arcade-tools",
+ destination:
+ "/:locale/get-started/agent-frameworks/langchain/use-arcade-with-langchain",
permanent: true,
},
{
source: "/:locale/home/langchain/user-auth-interrupts",
destination:
- "/:locale/get-started/agent-frameworks/langchain/user-auth-interrupts",
+ "/:locale/get-started/agent-frameworks/langchain/use-arcade-with-langchain",
+ permanent: true,
+ },
+ {
+ source:
+ "/:locale/guides/agent-frameworks/langchain/user-auth-interrupts",
+ destination:
+ "/:locale/get-started/agent-frameworks/langchain/use-arcade-with-langchain",
permanent: true,
},
{
@@ -450,7 +478,7 @@ const nextConfig: NextConfig = withLlmsTxt({
{
source: "/:locale/guides/agent-frameworks/langchain/python",
destination:
- "/:locale/get-started/agent-frameworks/langchain/use-arcade-tools",
+ "/:locale/get-started/agent-frameworks/langchain/use-arcade-with-langchain",
permanent: true,
},
{
diff --git a/public/llms.txt b/public/llms.txt
index 67d3dc127..b9466f87b 100644
--- a/public/llms.txt
+++ b/public/llms.txt
@@ -1,4 +1,4 @@
-
+
# Arcade
@@ -120,7 +120,6 @@ Arcade delivers three core capabilities: Deploy agents even your security team w
- [Environment Variables](https://docs.arcade.dev/en/resources/integrations/social-communication/slack/environment-variables.md): This documentation page provides guidance on configuring environment variables related to Slack API interactions, specifically `SLACK_MAX_CONCURRENT_REQUESTS`, `MAX_PAGINATION_SIZE_LIMIT`, and `MAX_PAGINATION_TIMEOUT_SECONDS`. Users will learn how to adjust these settings
- [Evaluate Tools](https://docs.arcade.dev/en/guides/create-tools/evaluate-tools.md): The "Evaluate Tools" documentation page provides guidance on systematically testing and enhancing tools using Arcade's evaluation framework. It helps users validate the performance of their tools after initial development and offers techniques for iterative improvements to ensure reliability in production.
- [ExaApi](https://docs.arcade.dev/en/resources/integrations/search/exa-api.md): The ExaApi documentation provides users with a comprehensive guide to utilizing the Exa.ai Search API, enabling them to conduct searches, manage websets, and handle research requests effectively. It outlines various tools available within the API, detailing their functionalities such as
-- [Fetch the "ScrapeUrl" tool from the "Firecrawl" MCP Server](https://docs.arcade.dev/en/get-started/agent-frameworks/langchain/use-arcade-tools.md): This documentation page provides a comprehensive guide on integrating Arcade tools into LangGraph applications, detailing prerequisites, environment setup, API key configuration, and tool management. Users will learn how to create and manage AI models, configure agents, and stream responses while leveraging specific
- [Figma](https://docs.arcade.dev/en/resources/integrations/development/figma.md): This documentation page provides users with a comprehensive guide to the Figma MCP Server, enabling interaction with Figma's design files, components, and collaboration features through the Figma REST API. Users can learn to access file structures, manage components, add comments
- [FigmaApi](https://docs.arcade.dev/en/resources/integrations/productivity/figma-api.md): The FigmaApi documentation provides a comprehensive guide for developers to utilize tools that enable interaction with the Figma API, facilitating efficient management of design assets and collaboration on projects. Users can learn how to perform various actions such as retrieving Figma files, managing
- [Firecrawl](https://docs.arcade.dev/en/resources/integrations/development/firecrawl.md): The Firecrawl documentation provides users with a comprehensive guide to utilizing the Arcade Firecrawl MCP Server, enabling them to build agents and AI applications for scraping, crawling, and mapping websites. It outlines available tools, including functionalities for scraping URLs, crawling websites,
@@ -165,7 +164,6 @@ Arcade delivers three core capabilities: Deploy agents even your security team w
- [HubspotUsersApi](https://docs.arcade.dev/en/resources/integrations/sales/hubspot-users-api.md): The HubspotUsersApi documentation provides users with tools to efficiently manage users and teams within a HubSpot account, including functionalities for retrieving user lists, creating and updating user accounts, and removing users. It offers detailed descriptions of available API tools, along with
- [Imgflip](https://docs.arcade.dev/en/resources/integrations/entertainment/imgflip.md): The Imgflip documentation provides users with tools to create and manage memes using the Imgflip API, enabling the development of agents and AI applications. Users can search for meme templates, retrieve popular memes, and create custom memes by adding text to existing templates.
- [Imgflip](https://docs.arcade.dev/en/resources/integrations/entertainment/spotify/imgflip.md): The Imgflip documentation page provides users with tools to create and manage memes using the Imgflip API, allowing them to search for meme templates, retrieve popular templates, and create custom memes. It outlines the available features, including a premium search option and customizable
-- [Import necessary classes and modules](https://docs.arcade.dev/en/get-started/agent-frameworks/langchain/user-auth-interrupts.md): This documentation page guides users in creating a LangGraph workflow that incorporates user authorization for specific Arcade tools, ensuring that only authorized tools are accessible to the language model. It provides step-by-step instructions on setting up the environment, defining workflow functions, and compiling
- [In Custom Applications](https://docs.arcade.dev/en/guides/tool-calling/custom-apps.md): This documentation page provides guidance on integrating Arcade tools into custom applications, focusing on user authentication, authorization status checking, and managing tool definitions. It serves as a resource for developers building tool-calling interfaces to ensure proper implementation and functionality.
- [Initialize the Arcade client](https://docs.arcade.dev/en/get-started/agent-frameworks/google-adk/use-arcade-tools.md): This documentation page provides a comprehensive guide for integrating Arcade tools into Google ADK applications, detailing the necessary prerequisites, environment setup, and configuration steps. Users will learn how to create and manage Arcade tools, authorize them for agents, and run these agents with
- [IntercomApi](https://docs.arcade.dev/en/resources/integrations/customer-support/intercom-api.md): The IntercomApi documentation provides a comprehensive guide to tools that enable users to interact with the Intercom platform using OAuth2 authentication. It details various functionalities, such as managing admin information, creating and updating articles, and handling company data, allowing users to