How to create a Langchain AI agent with a tool using Deepseek-R1 available in AzureOpenAI?

[leockl]

Azure is currently offering Deepseek-R1 for free and I have now setup my Python script to use Deepseek-R1 via the Azure's library AzureOpenAI.

How do I now build a Langchain or Langgraph AI agent with a tool using Deepseek-R1 available in AzureOpenAI? Is it also possible to use the React framework available in Langchain or Langgraph to build this AI agent with a tool?

[dosubot[bot]]

To create a LangChain AI agent with a tool using Deepseek-R1 available in AzureOpenAI, follow these steps:

1. Setup Deepseek-R1: Ensure you have created a DeepSeek account, generated an API key, and set the DEEPSEEK_API_KEY environment variable in your Python script.

   import getpass
   import os
   
   if not os.getenv("DEEPSEEK_API_KEY"):
       os.environ["DEEPSEEK_API_KEY"] = getpass.getpass("Enter your DeepSeek API key: ")

2. Install Required Package: Install the langchain-deepseek-official package.

   pip install -U langchain-deepseek-official

3. Instantiate the Model: Use the ChatDeepSeek class to instantiate the model.

   from langchain_deepseek import ChatDeepSeek
   
   llm = ChatDeepSeek(
       model="deepseek-chat",
       temperature=0,
       max_tokens=None,
       timeout=None,
       max_retries=2,
   )

4. Create a Tool: Define a tool using the @tool decorator from langchain_core.tools.

   from langchain_core.tools import tool
   
   @tool
   def multiply(first_int: int, second_int: int) -> int:
       """Multiply two integers together."""
       return first_int * second_int

5. Bind Tools to the Model: Use bind_tools to associate the tool with the model.

   llm_with_tools = llm.bind_tools([multiply])

6. Create an Agent: Use the create_tool_calling_agent function to create an agent.

   from langchain.agents import create_tool_calling_agent
   
   tools = [multiply]
   agent = create_tool_calling_agent(llm, tools)

7. Create an Agent Executor: Construct an AgentExecutor to process queries.

   from langchain.agents import AgentExecutor
   
   agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

8. Invoke the Agent: Use the agent executor to process queries.

   agent_executor.invoke(
       {
           "input": "What's four times 23"
       }
   )

Regarding the use of the React framework within LangChain, there is no specific documentation or examples available for integrating React with LangChain to build AI agents ^[1][2][3].

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[leockl]

Can you tell me how do I create a Langchain AI agent with a tool using any LLM of your choice available in LangChain's AzureOpenAI class and/or AzureChatOpenAI class?

[dosubot[bot]]

To create a LangChain AI agent with a tool using any LLM available in LangChain's AzureOpenAI or AzureChatOpenAI class, follow these steps:

1. Instantiate the LLM: Use the AzureChatOpenAI class to create an instance of the language model.

2. Define the Tools: Create classes for the tools you want to use, inheriting from BaseModel and defining the necessary fields.

3. Bind the Tools: Use the bind_tools method to bind the tools to the LLM instance.

4. Invoke the LLM with Tools: Use the invoke method to call the LLM with a query that utilizes the tools.

Here's a code example:

from langchain_openai import AzureChatOpenAI
from pydantic import BaseModel, Field

# Step 1: Instantiate the LLM
llm = AzureChatOpenAI(
    azure_deployment="your-deployment",
    api_version="2024-05-01-preview",
    temperature=0,
    max_tokens=None,
    timeout=None,
    max_retries=2,
)

# Step 2: Define the Tools
class GetWeather(BaseModel):
    '''Get the current weather in a given location'''
    location: str = Field(..., description="The city and state, e.g. San Francisco, CA")

class GetPopulation(BaseModel):
    '''Get the current population in a given location'''
    location: str = Field(..., description="The city and state, e.g. San Francisco, CA")

# Step 3: Bind the Tools
llm_with_tools = llm.bind_tools([GetWeather, GetPopulation])

# Step 4: Invoke the LLM with Tools
ai_msg = llm_with_tools.invoke("Which city is hotter today and which is bigger: LA or NY?")
print(ai_msg.tool_calls)

This setup allows you to create an AI agent using the AzureChatOpenAI class, define tools for specific tasks, bind these tools to the LLM, and invoke the LLM with a query that uses the tools ^[1].

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[leockl]

In the Python script you provided directly above, where do I specify my Azure's endpoint and Azure's API key?

[dosubot[bot]]

In the Python script provided, you can specify your Azure endpoint and Azure API key directly when instantiating the AzureChatOpenAI class. Here's how you can do it:

from langchain_openai import AzureChatOpenAI

llm = AzureChatOpenAI(
    azure_endpoint="https://<your-endpoint>.openai.azure.com/",
    api_key="your-api-key",
    azure_deployment="your-deployment",
    api_version="2024-05-01-preview",
    temperature=0,
    max_tokens=None,
    timeout=None,
    max_retries=2,
)

Alternatively, if you prefer to use environment variables, you can set them as follows:

export AZURE_OPENAI_API_KEY="your-api-key"
export AZURE_OPENAI_ENDPOINT="https://<your-endpoint>.openai.azure.com/"

The AzureChatOpenAI class will automatically infer these values from the environment variables AZURE_OPENAI_ENDPOINT and AZURE_OPENAI_API_KEY if they are not provided directly in the constructor ^[1].

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[leockl]

In the same Python script you provided above, can I use methods "from langchain_core.tools import Tool" to create the two tools rather than using methods "from pydantic import BaseModel, Field"?

[leockl]

Problem solved

[aiwalter]

@dosubot How to use DeepSeek Chat model via Azure AI Studio aka AI Foundry?

[dosubot[bot]]

To use the DeepSeek Chat model via Azure AI Studio (AI Foundry), you need to deploy the model on Azure ML or Azure AI Studio and obtain the necessary parameters. Here's a Python example using the AzureMLChatOnlineEndpoint class from the langchain_community package:

from langchain_community.chat_models.azureml_endpoint import (
    AzureMLChatOnlineEndpoint,
    AzureMLEndpointApiType,
    CustomOpenAIChatContentFormatter,
)
from langchain_core.messages import HumanMessage

# Set up the chat model with your endpoint details
chat = AzureMLChatOnlineEndpoint(
    endpoint_url="https://<your-endpoint>.<your_region>.inference.ml.azure.com/score",
    endpoint_api_type=AzureMLEndpointApiType.dedicated,  # or AzureMLEndpointApiType.serverless for pay-as-you-go
    endpoint_api_key="your-api-key",
    content_formatter=CustomOpenAIChatContentFormatter(),
)

# Invoke the chat model with a message
response = chat.invoke(
    [HumanMessage(content="Will the Collatz conjecture ever be solved?")]
)

# Print the response
print(response)

Make sure to replace <your-endpoint>, <your_region>, and "your-api-key" with your actual endpoint URL, region, and API key. You can also adjust the endpoint_api_type based on your deployment type (dedicated or serverless) ^[1].

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}