Sending a Message with LangChain

Introduction to LangChain and Large Language Models

Welcome to the first lesson of the LangChain Chat Essentials in JavaScript course. In this course, we will embark on an exciting journey into the world of conversational AI using LangChain in the JavaScript ecosystem. LangChain is a powerful framework that simplifies the process of interacting with large language models (LLMs). It provides developers with a set of tools and interfaces to effectively utilize AI capabilities for a wide range of applications, such as chatbots, content generation, and more. LangChain abstracts the complexities involved in model communication, allowing developers to focus on building innovative solutions. Beyond basic interactions, LangChain offers advanced features like conversation history management, context handling, and customizable model parameters. These features make it an excellent choice for developing sophisticated AI-driven applications. In this lesson, we will concentrate on the essential skills needed to send messages to AI models using LangChain. While LangChain supports a variety of models and providers, we will specifically focus on working with OpenAI, laying the groundwork for more advanced topics in future lessons.

Setting Up the Environment

Before we dive into the code, it's important to ensure that your JavaScript environment is set up correctly. You will need to install the @langchain/openai package, which provides the necessary components to work with OpenAI models through the LangChain framework. The @langchain/openai package is specifically designed to integrate OpenAI's models with LangChain's architecture. It contains all the classes and utilities needed to communicate with OpenAI's API. To install this library, you can use the following npm command: Shell npm install @langchain/openai This single package provides everything you need to start working with OpenAI models in LangChain. It handles the API communication, response parsing, and model configuration, allowing you to focus on building your applications rather than managing the underlying infrastructure.

Setting the OpenAI API Key as an Environment Variable

In this course, you'll be using the CodeSignal coding environment, where we've already set up everything you need to start working with OpenAI models. This means you don't need to worry about setting up an API key or configuring environment variables—it's all taken care of for you. However, it's still useful to understand how this process works in case you want to set it up on your own computer in the future. To work with OpenAI models outside of CodeSignal, you need to set up a payment method and obtain an API key from their website. This API key is essential for accessing OpenAI's services and making requests to their API. To keep your API key secure, you can use an environment variable. An environment variable is like a special note that your computer can read to find out important details, such as your OpenAI API key, without having to write it directly in your code. This helps keep your key safe and secure. If you were setting this up on your own system, here's how you would do it: On macOS and Linux, open your terminal and use the export command to set the environment variable: Shell export OPENAI_API_KEY=your_api_key_here For Windows, you can set the environment variable using the set command in the Command Prompt: Visual Basic set OPENAI_API_KEY=your_api_key_here If you are using PowerShell, use the following command: PowerShell $env:OPENAI_API_KEY="your_api_key_here" These commands will set the environment variable for the current session. But remember, while using CodeSignal, you can skip these steps and jump straight into experimenting with OpenAI models.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

With your OpenAI API key securely set as an environment variable, you can now utilize LangChain to communicate with OpenAI models. The ChatOpenAI class is a crucial part of LangChain that enables communication with OpenAI's chat-based models like gpt-5.6-luna and gpt-5.6-sol. It acts as a bridge, allowing you to send messages to the AI and receive responses in a conversational format.

JavaScript

import { ChatOpenAI } from "@langchain/openai";

// Create a ChatOpenAI instance
const chat = new ChatOpenAI({
  model: "gpt-5.6-luna",
  reasoningEffort: "none",
});

import { ChatOpenAI } from "@langchain/openai";

// Create a ChatOpenAI instance
const chat = new ChatOpenAI({
  model: "gpt-5.6-luna",
  reasoningEffort: "none",
});

In this code snippet, we import ChatOpenAI from the LangChain library and create an instance named chat. This instance is ready to send messages to the AI model, utilizing the OpenAI API key set as an environment variable for secure and authenticated access. By default, the ChatOpenAI object uses OpenAI's default settings and model. While it offers customization options, we'll concentrate on basic usage for now.

To communicate with the OpenAI model, you can send a message using the invoke method of the ChatOpenAI instance. This method takes a message and returns the AI's response.

JavaScript

// Send a message to the AI model
const response = await chat.invoke("Hello, how are you?");

// Send a message to the AI model
const response = await chat.invoke("Hello, how are you?");

In this example, we send a single message, "Hello, how are you?", to the model. The invoke method processes this message and returns a response object containing the AI's reply. Note that we're using await to handle the asynchronous nature of the method call, which is a common practice in JavaScript for dealing with promises.

In our coding environment, we're using modern JavaScript features that allow us to use await at the top level without wrapping it in an async function. This makes our code cleaner and more straightforward. In other environments, you might need to wrap this code in an async function or use .then() chains.

Once you have the response from the AI model, you need to extract the content to understand the model's reply. The response object contains the AI's generated text, which you can access using the content property.

JavaScript

// Print the AI's response
console.log("AI Response:");
console.log(response.content);

// Print the AI's response
console.log("AI Response:");
console.log(response.content);

Here, we print the AI's response to the console. By accessing response.content, we retrieve the text of the AI's reply, which in this case might be something like:

text

AI Response:
I'm an AI model, so I don't have feelings, but I'm here to help you!

AI Response:
I'm an AI model, so I don't have feelings, but I'm here to help you!

Understanding how to extract and interpret the AI's response is essential for building applications that effectively interact with AI models. As you experiment with different messages, observe how the AI responds and think about how you can use this information in your projects.

Let's put everything together to see a complete example of sending a message to an OpenAI model using LangChain:

JavaScript

import { ChatOpenAI } from "@langchain/openai";

// Create a ChatOpenAI instance
const chat = new ChatOpenAI({
  model: "gpt-5.6-luna",
  reasoningEffort: "none",
});

// Send a message to the AI model
const response = await chat.invoke("Hello, how are you?");

// Print the AI's response
console.log("AI Response:");
console.log(response.content);

import { ChatOpenAI } from "@langchain/openai";

// Create a ChatOpenAI instance
const chat = new ChatOpenAI({
  model: "gpt-5.6-luna",
  reasoningEffort: "none",
});

// Send a message to the AI model
const response = await chat.invoke("Hello, how are you?");

// Print the AI's response
console.log("AI Response:");
console.log(response.content);

This simple script demonstrates the entire process: importing the necessary class, creating a ChatOpenAI instance, sending a message to the model, and extracting the response. When you run this code, you'll see the AI's reply printed to the console.

Working with Other AI Providers in LangChain

One of the powerful features of LangChain is its ability to work with various language models beyond just OpenAI. The interface remains consistent across different model providers, making it easy to switch between them or even compare responses from multiple models for the same prompt. This flexibility allows you to choose the model that best suits your specific needs, budget, or performance requirements.

For instance, LangChain provides seamless integration with Anthropic's Claude models. To use Claude with LangChain, you first need to install the appropriate package:

Shell

npm install @langchain/anthropic

npm install @langchain/anthropic

You'll also need to set up your Anthropic API key as an environment variable:

Shell

# On macOS/Linux
export ANTHROPIC_API_KEY=your_anthropic_api_key_here

# On Windows (Command Prompt)
set ANTHROPIC_API_KEY=your_anthropic_api_key_here

# On Windows (PowerShell)
$env:ANTHROPIC_API_KEY="your_anthropic_api_key_here"

# On macOS/Linux
export ANTHROPIC_API_KEY=your_anthropic_api_key_here

# On Windows (Command Prompt)
set ANTHROPIC_API_KEY=your_anthropic_api_key_here

# On Windows (PowerShell)
$env:ANTHROPIC_API_KEY="your_anthropic_api_key_here"

Then, you can use Claude in a similar way to how we used OpenAI, but with one key difference - you need to specify which Claude model you want to use:

JavaScript

import { ChatAnthropic } from "@langchain/anthropic";

// Create an instance of ChatAnthropic with a specific model
const chat = new ChatAnthropic({
  model: "claude-sonnet-5"
});

// Send a message to Claude
const response = await chat.invoke("Hello, how are you?");

// Display Claude's response
console.log("Claude's Response:");
console.log(response.content);

import { ChatAnthropic } from "@langchain/anthropic";

// Create an instance of ChatAnthropic with a specific model
const chat = new ChatAnthropic({
  model: "claude-sonnet-5"
});

// Send a message to Claude
const response = await chat.invoke("Hello, how are you?");

// Display Claude's response
console.log("Claude's Response:");
console.log(response.content);

Unlike ChatOpenAI which uses a default model if none is specified, ChatAnthropic requires you to explicitly select a model like "claude-sonnet-5".

This model-agnostic approach is one of LangChain's greatest strengths, allowing you to experiment with different models without significantly changing your code structure. In future lessons, we'll explore more advanced techniques for working with various models and customizing their parameters.

LangChain also supports integration with local language models, which can be beneficial when you need to work offline, have privacy concerns, or want to reduce API costs. Local models run directly on your machine, eliminating the need for internet connectivity and external API calls.

To use a local model with LangChain, you'll need to install the appropriate packages. For example, to work with Ollama, a tool for running local models like Llama 3.2:

Shell

npm install @langchain/ollama

npm install @langchain/ollama

Once installed, you can use local models in a similar way to cloud-based ones:

JavaScript

import { ChatOllama } from "@langchain/ollama";

// Create a chat instance for a local model
const chat = new ChatOllama({
  model: "llama3.2:3b"
});

// Send a message to the local model
const response = await chat.invoke("Hello, how are you?");

// Display the response
console.log("Local Model Response:");
console.log(response.content);

import { ChatOllama } from "@langchain/ollama";

// Create a chat instance for a local model
const chat = new ChatOllama({
  model: "llama3.2:3b"
});

// Send a message to the local model
const response = await chat.invoke("Hello, how are you?");

// Display the response
console.log("Local Model Response:");
console.log(response.content);

This code connects to a locally running Ollama server and uses the Llama 3.2 model to generate a response. The interface remains consistent with what we've seen for cloud-based models, making it easy to switch between different model providers based on your specific requirements.

In this lesson, we covered the basics of sending a message to an AI model using LangChain. You learned how to set up your environment, initialize the ChatOpenAI object, and send a simple message to the model. We also briefly explored how LangChain's consistent interface allows you to work with various AI providers like Anthropic's Claude and local models through Ollama.

As you move on to the practice exercises, I encourage you to experiment with different messages and observe how the AI responds. This foundational skill will be built upon in future lessons, where we will explore more advanced topics such as customizing model parameters and managing conversation history.

Congratulations on completing the first step in your journey into conversational AI with LangChain!

Introduction to LangChain and Large Language Models

Setting Up the Environment

Setting the OpenAI API Key as an Environment Variable

Join the 1M+ learners on CodeSignal

Understanding the ChatOpenAI Class

Sending a Message

Extracting the Response

Complete Code Example

Working with Other AI Providers in LangChain

Working with Local Models in LangChain

Summary and Next Steps