LangChain & NVIDIA NIM: AI Innovation at GTC 2025

What Are LangChain Tools and How Do They Work?

from langchain.tools import tool
from datetime import datetime

@tool
def get_current_time() -> str:
    """Returns the current date and time."""
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

# Using the tool
print(get_current_time())  # Example call

What is a ReAct Agent in LangChain?

• Thinks Before Acting - Uses chain-of-thought reasoning before executing a tool.
• Iterates Dynamically - Can call multiple tools in a sequence, refining its approach based on intermediate results.
• Handles Unknown Problems - Unlike fixed pipelines, it figures out how to solve problems dynamically.
• Explains Its Thought Process - The agent explicitly logs its reasoning before making a decision.

from langchain.agents import initialize_agent
from langchain.tools import Tool
from langchain.llms import OpenAI

llm = OpenAI(temperature=0)

tools = [
    Tool(
        name="Current Time",
        func=get_current_time,
        description="Returns the current time."
    )
]

agent = initialize_agent(tools, llm, agent="react", verbose=True)
response = agent.run("What is the current time?")
print(response)

Chaining Actions in LangChain

from langchain.chains import SimpleSequentialChain

# First LLM chain: Generate a topic
first_prompt = PromptTemplate(
    input_variables=["interest"],
    template="Suggest a technical topic related to {interest}."
)
first_chain = LLMChain(llm=llm, prompt=first_prompt)

# Second LLM chain: Generate a summary for the topic
second_prompt = PromptTemplate(
    input_variables=["topic"],
    template="Write a brief explanation about {topic}."
)
second_chain = LLMChain(llm=llm, prompt=second_prompt)

# Create a Sequential Chain
overall_chain = SimpleSequentialChain(chains=[first_chain, second_chain], verbose=True)

# Run the chain
response = overall_chain.run("machine learning")
print(response)

What is a Runnable in LangChain?

from langchain.schema.runnable import RunnableLambda

def process_data(x):
    return f"Processed data: {x}"

runnable = RunnableLambda(process_data)
output = runnable.invoke("AI-powered by NVIDIA")
print(output)

Understanding the Message Object in LangChain

• HumanMessage represents a user’s input, optionally enriched with metadata like location or request-specific details.
• AIMessage contains the model’s response, potentially including metadata like the source of the information.
• SystemMessage provides overarching instructions to guide the model’s behavior, ensuring more consistent responses.

from langchain.schema import HumanMessage, AIMessage, SystemMessage

# HumanMessage with basic attributes
user_msg = HumanMessage(
    content="What's the weather like in New York?",
    additional_kwargs={"location": "New York"}
)

# AIMessage with additional metadata
ai_msg = AIMessage(
    content="The weather in New York is 22°C with clear skies.",
    additional_kwargs={"source": "Weather API"}
)

# SystemMessage with a role name
system_msg = SystemMessage(
    content="You are a helpful weather assistant.",
    name="assistant_instructions"
)

# Print attributes
print(user_msg.type)  # "human"
print(user_msg.content)  # "What's the weather like in New York?"
print(user_msg.additional_kwargs)  # {"location": "New York"}
print(system_msg.name)  # "assistant_instructions"

Using LangChain’s Built-in Memory Components

• ConversationBufferMemory – Stores a fixed-length buffer of previous interactions.
• ConversationBufferWindowMemory – Keeps only the most recent interactions, discarding older ones.
• ConversationTokenBufferMemory – Maintains memory up to a specific token limit, ensuring it fits within model constraints.
• ConversationSummaryMemory – Generates a concise summary of past interactions instead of storing raw messages.

from langchain.memory import ConversationSummaryMemory
from langchain.chat_models import ChatOpenAI

llm = ChatOpenAI(temperature=0)
memory = ConversationSummaryMemory(llm=llm)

# Simulating conversation history
memory.save_context({"input": "What is LangChain?"}, {"output": "LangChain is a framework for building AI applications."})
print(memory.load_memory_variables({}))  # Retrieves summarized memory

The Future of AI with LangChain and NVIDIA NIM