## **TL;DR**

- This guide shows how to build an AI agent that connects to the Extend API using LangChain and the React (Reasoning + Acting) agent pattern.
- The agent can manage virtual cards, view credit card info, track transactions, and categorize expenses through the Extend AI Toolkit.
- Setup involves configuring your Extend and OpenAI API keys, installing dependencies, and initializing a LangChain GPT-4o model with Extend’s toolkit tools.
- The React agent uses reasoning and action loops to decide what API calls to make and respond intelligently to prompts like “Show me transactions from last month.”
- Together, LangChain and the Extend API enable developers to embed spend management automation into AI workflows, laying the groundwork for smarter, finance-aware applications.

In this blog post, we'll explore how to build an AI agent that can interact with the Extend API using LangChain and the React agent pattern. We'll cover the background of these technologies, how they work together, and provide a step-by-step guide to create your own agent.

## What is LangChain?

[**LangChain**](https://github.com/langchain-ai/langchain) is a framework for developing applications powered by language models. It provides a set of abstractions and tools that make it easier to build complex applications with LLMs (Large Language Models). LangChain enables developers to:

- Connect LLMs to external data sources
- Create chains of operations that can be executed in sequence
- Build agents that can use tools to accomplish tasks
- Manage memory and context for conversations

LangChain has become a popular choice for developers building AI applications because it simplifies the integration of LLMs into existing systems and workflows.

## What is a React Agent?

The React agent pattern (Reasoning and Acting) is a powerful approach to building AI agents that can solve complex tasks. The name "React" comes from the pattern of alternating between:

**1. Reasoning:** The agent thinks about what to do next

**2. Acting:** The agent takes an action based on its reasoning

This pattern allows the agent to:

- Break down complex problems into smaller steps
- Use tools to gather information or perform actions
- Learn from the results of its actions
- Adapt its approach based on feedback

React agents are particularly effective for tasks that require multiple steps or the use of external tools, making them ideal for interacting with APIs like Extend.

## The Extend AI Toolkit

The [**Extend AI Toolkit**](/content/ai-toolkit/index.html) is an open-source library that provides tools for integrating with the Extend API in various AI agent frameworks, including LangChain.

It enables AI agents to:

- Manage virtual cards
- View credit card information
- Track transactions
- Categorize expenses

The toolkit abstracts away the complexity of API interactions, allowing developers to focus on building powerful AI agents that can help users manage their finances.

## Setting up your environment

Before we start building our agent, let's set up our development environment:

**1. Install Python 3.12 or higher if you don't already have it.**

**2. Create a virtual environment (recommended):**

```bash
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
```

**3. Install the required packages:**

```bash
pip install extend-ai-toolkit langchain langchain-openai python-dotenv
```

**4. Set up your Extend API credentials:**

Create a `.env` file in your project directory with the following content:

```bash
EXTEND_API_KEY=your_api_key_here
EXTEND_API_SECRET=your_api_secret_here
ORGANIZATION_ID=your_org_id_here
OPENAI_API_KEY=your_openai_api_key_here
```

You'll need to obtain these credentials from your Extend account. If you don't have an account yet, you can sign up at [**app.paywithextend.com**](http://app.paywithextend.com/) and follow our [**Getting Started Guide**](https://paywithextend.stoplight.io/docs/extend-api/be33ffa3718f0-setting-up-your-api-access).

**5. Set up your OpenAI API key:**

To use LangChain with GPT models, you'll need an OpenAI API key:

1. Go to [OpenAI's platform](https://platform.openai.com/)
2. Sign up for an account or log in if you already have one
3. Navigate to the [**API keys section**](https://platform.openai.com/api-keys)
4. Click "Create new secret key"
5. Give your key a name (e.g., "Extend Agent")
6. Copy the generated API key and add it to your `.env` file as `OPENAI_API_KEY`

Note💡

OpenAI offers a free tier with limited usage, but you may need to add a payment method to access GPT-4 models.

## **Building the React Agent**

Now, let's create a Python script that sets up a LangChain React agent with the Extend AI Toolkit. We'll break this down into logical sections to understand each component.

**1. Imports and environment setup**

First, let's import the necessary libraries and set up our environment variables:

```python
import os

import asyncio

from dotenv import load_dotenv

from langchain_openai import ChatOpenAI

from langgraph.prebuilt import create_react_agent

from langchain_core.messages import SystemMessage, AIMessage, HumanMessage

from extend_ai_toolkit.langchain.toolkit import ExtendLangChainToolkit

from extend_ai_toolkit.shared import Configuration, Scope, Product, Actions

# Load environment variables
load_dotenv()

# Get required environment variables
api_key = os.environ.get("EXTEND_API_KEY")
api_secret = os.environ.get("EXTEND_API_SECRET")
org_id = os.environ.get("ORGANIZATION_ID")

# Validate environment variables
if not all([api_key, api_secret, org_id]):

raise ValueError("Missing required environment variables.\n  Please set EXTEND_API_KEY, EXTEND_API_SECRET,\n  and ORGANIZATION_ID")
```

This section handles importing all necessary libraries and setting up environment variables. We use `python-dotenv` to load variables from our `.env` file and validate that all required credentials are present.

**2. Language model configuration**

Next, we set up our language model:

```python
# Initialize the language model
llm = ChatOpenAI(
	model="gpt-4o",
  # You can also use "gpt-3.5-turbo" for a
  more cost-effective option
)
```

Here, we're using OpenAI's GPT-4o model through LangChain's `ChatOpenAI` class. You can also use GPT-3.5-turbo for a more cost-effective option, though it may have slightly reduced capabilities.

**3. Extend Toolkit configuration**

Now, let's configure the Extend AI Toolkit with appropriate permissions:

```python
# Create the Extend LangChain toolkit with appropriate permissions
extend_langchain_toolkit = ExtendLangChainToolkit(
	org_id,
  api_key,
  api_secret,
  Configuration(
   	scope=[
		Scope(Product.VIRTUAL_CARDS, actions=Actions(read=True)),
		Scope(Product.CREDIT_CARDS, actions=Actions(read=True)),
		Scope(Product.TRANSACTIONS, actions=Actions(read=True)),
   	],
   	org_id=org_id
	)
)

# Get the tools from the toolkit

# Create the React agent
langgraph_agent_executor = create_react_agent(
	llm,
  tools
)
```

This section creates an instance of the Extend LangChain toolkit with read permissions for virtual cards, credit cards, and transactions. We then extract the tools from the toolkit, which will be used by our agent.

**5. Chat interface implementation**

Finally, let's implement the chat interface:

```python
# Function to interact with the agent
async def chat_with_agent():
	print("\nWelcome to the Extend AI Assistant!")
	print("You can ask me to:")
	print("- List all credit cards")
	print("- List all virtual cards")
	print("- Show details for a specific virtual card")
	print("- Show transactions for a specific period")
	print("- Show details for a specific transaction")
	print("- Create or update virtual cards")
	print("\nType 'exit' to end the conversation.\n")

while True:
		# Get user input
		user_input = input("\nYou: ").strip()

if user_input.lower() in ['exit', 'quit', 'bye']:
			print("\nGoodbye!")
			break

# Process the query
		result = await langgraph_agent_executor.ainvoke({
			"input": user_input,
			"messages": [{
				"content":"You are a helpful assistant that can interact with the Extend API to manage virtual cards, credit cards, and transactions."
			},{
				"content": user_input
			}]
		})

# Extract and print the assistant's message
		for message in result.get('messages', []):
			if isinstance(message, AIMessage):
				print("\nAssistant:", message.content)

if __name__ == "__main__":
	asyncio.run(chat_with_agent())
```

This section implements a simple chat interface that allows users to interact with the agent. It displays a welcome message with available capabilities, processes user input, and displays the agent's responses.

## **Running the agent**

To run the agent, simply execute the script:

```bash
python extend_agent.py
```

You'll be presented with a welcome message and a list of capabilities. You can then ask the agent questions like:

- "List all my virtual cards"
- "Show me transactions from last month"
- "Create a new virtual card for my marketing team"
- "What's the status of my credit card with ID 'card_123'?"

The agent will use the React pattern to:

1. Understand your request
2. Determine which tools to use
3. Execute the appropriate API calls
4. Format and return the results

## **Extending the agent**

The Extend AI Toolkit provides many more capabilities that you can add to your agent:

1. **Expense categories:** Add tools for managing expense categories and labels.
2. **Receipt management:** Enable the agent to handle receipt attachments.

To add these capabilities, simply update the `Configuration` object with the appropriate scopes and actions.

## **Conclusion**

In this blog post, we've explored how to build an AI agent that can interact with the Extend API using LangChain and the React agent pattern. We've covered:

- The basics of LangChain and React agents
- How to set up the Extend AI Toolkit
- How to create a custom agent with specific permissions
- How to interact with the agent to manage virtual cards, credit cards, and transactions

This agent can serve as a foundation for building more complex financial management applications. By combining the power of LangChain with the Extend API, you can create AI assistants that help users manage their finances more effectively.

To learn more about the Extend AI Toolkit, visit the [**GitHub repository**](https://github.com/paywithextend/extend-ai-toolkit). For more information about LangChain, check out the [**LangChain documentation**](https://python.langchain.com/docs/get_started/introduction).

Happy coding!

Build your AI agent with Extend.