pip install langchain-arcade langchain-openai langgraph

npm install @arcadeai/arcadejs @langchain/openai @langchain/core @langchain/langgraph

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")

ARCADE_API_KEY=<YOUR_ARCADE_API_KEY>
OPENAI_API_KEY=<YOUR_OPENAI_API_KEY>

from langchain_arcade import ArcadeToolManager
 
manager = ArcadeToolManager(api_key=arcade_api_key)
 
# Fetch the "ScrapeUrl" tool from the "Web" toolkit
tools = manager.get_tools(tools=["Web.ScrapeUrl"])
print(manager.tools)
 
# Get all tools from the "Google" toolkit
tools = manager.get_tools(toolkits=["Google"])
print(manager.tools)

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 toolkit (e.g. "github", "notion", "google", etc.)
const googleToolkit = await arcade.tools.list({ toolkit: "google", limit: 30 });
const arcadeTools = toZod({
	tools: googleToolkit.items,
	client: arcade,
	userId: "<YOUR_SYSTEM_USER_ID>", // 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);

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()

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();

from langgraph.prebuilt import create_react_agent
 
graph = create_react_agent(model=bound_model, tools=tools, checkpointer=memory)

import { createReactAgent } from "@langchain/langgraph/prebuilt";
 
const graph = createReactAgent({ llm: boundModel, tools, checkpointer: memory });

config = {
    "configurable": {
        "thread_id": "1",
        "user_id": "user@example.coom"
    }
}
user_input = {
    "messages": [
        ("user", "List any new and important emails in my inbox.")
    ]
}

const config = {
	configurable: {
		thread_id: "1",
		user_id: "user@example.com",
	},
	streamMode: "values" as const,
};
const user_input = {
	messages: [
		{
			role: "user",
			content: "List any new and important emails in my inbox.",
		},
	],
};

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.")

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);
}