Introduction to LangChain and Large Language Models in Go

Welcome to the first lesson of the LangChain Chat Essentials in Go course. In this course, we will explore the exciting world of conversational AI using LangChain with Go.

LangChain is a robust framework that simplifies the interaction with large language models (LLMs). It provides developers with tools and interfaces to effectively utilize AI capabilities for various applications, such as chatbots and content generation. LangChain abstracts the complexities involved in model communication, allowing developers to focus on building innovative solutions. It offers advanced features like conversation history management, context handling, and customizable model parameters, making it an excellent choice for developing sophisticated AI-driven applications.

In this lesson, we will focus on the essential skills needed to send messages to AI models using LangChain in Go. 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.

Before diving into the code, it's important to ensure that your Go environment is set up correctly. You will need to install the necessary Go packages to work with OpenAI models through the LangChain framework.

To get started, ensure you have Go installed on your system. You can download it from the official Go website. Once Go is installed, you can set up your project and install the required packages.

Create a new Go module for your project:

go mod init langchain-chat

Next, you will need to install the langchaingo package, which provides the necessary components to work with OpenAI models through the LangChain framework. You can do this by running:

go get github.com/tmc/langchaingo

This package provides everything you need to start working with OpenAI models in LangChain. It handles API communication, response parsing, and model configuration, allowing you to focus on building your applications rather than managing the underlying infrastructure.

In this course, you'll be using a development 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 this environment, 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. Here's how you would set it up:

• 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 the provided environment, you can skip these steps and jump straight into experimenting with OpenAI models.

With your OpenAI API key securely set as an environment variable, you can now utilize LangChain to communicate with OpenAI models. In Go, you will use the OpenAI LLM (Large Language Model) to interact with OpenAI's models. It acts as a bridge, allowing you to send messages to the AI and receive responses.

package main

import (
    "context"
    "fmt"
    "log"
    
    "codesignal/llmconfig"

    "github.com/tmc/langchaingo/llms/openai"
)

func main() {
    // Create an instance of OpenAI LLM
    llm, err := openai.New(openai.WithModel("gpt-5.6-luna"), openai.WithHTTPClient(llmconfig.ReasoningNone()))
    if err != nil {
        log.Fatal(err)
    }   
}

In this code snippet, we import the necessary packages and create an instance of the OpenAI LLM. 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.

We pass two options to openai.New. openai.WithModel("gpt-5.6-luna") selects the model, and openai.WithHTTPClient(llmconfig.ReasoningNone()) turns off the model's reasoning step so it answers directly and quickly. The llmconfig package is a small helper included in your environment: it adds "reasoning_effort": "none" to each chat request, a setting this version of LangChainGo can't send on its own. You'll see this option in every example in this course.

To communicate with the OpenAI model, you can send a message using the Call method of the LLM instance. This method takes a context and a string message, returning the AI's response.

// Create a context
ctx := context.Background()

// Send a message to the AI model
completion, err := llm.Call(ctx, "Hello, how are you?")
if err != nil {
    log.Fatal(err)
}

In this example, we create a context and send a single message, "Hello, how are you?", to the model. The Call method processes this message and returns the AI's reply as a string.

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

package main

import (
    "context"
    "fmt"
    "log"
    
    "codesignal/llmconfig"

    "github.com/tmc/langchaingo/llms/openai"
)

func main() {
    // Create an instance of OpenAI LLM
    llm, err := openai.New(openai.WithModel("gpt-5.6-luna"), openai.WithHTTPClient(llmconfig.ReasoningNone()))
    if err != nil {
        log.Fatal(err)
    }

    // Create a context
    ctx := context.Background()

    // Send a message to the AI model
    completion, err := llm.Call(ctx, "Hello, how are you?")
    if err != nil {
        log.Fatal(err)
    }

    // Display the AI's response
    fmt.Println(completion)
}

This script demonstrates the entire process: importing the necessary packages, creating an LLM instance, setting up a context, sending a message, and displaying the response.

LangChain supports 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.

For example, to use Anthropic's Claude models:

package main

import (
    "context"
    "fmt"
    "log"
    "os"
    
    "github.com/tmc/langchaingo/llms/anthropic"
)

func main() {
    llm, err := anthropic.New(anthropic.WithModel("claude-sonnet-4-5"), anthropic.WithBaseURL(os.Getenv("ANTHROPIC_API_BASE")))
    if err != nil {
        log.Fatal(err)
    }

    ctx := context.Background()
    completion, err := llm.Call(ctx, "Hello, how are you?")
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(completion)
}

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. For example, to work with Ollama:

package main

import (
    "context"
    "fmt"
    "log"
    
    "github.com/tmc/langchaingo/llms/ollama"
)

func main() {
    llm, err := ollama.New(ollama.WithModel("llama2"))
    if err != nil {
        log.Fatal(err)
    }

    ctx := context.Background()
    completion, err := llm.Call(ctx, "Hello, how are you?")
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(completion)
}

In this lesson, we covered the basics of sending a message to an AI model using LangChain in Go. You learned how to set up your environment, initialize the OpenAI LLM, and send messages to the model with custom parameters. We also explored how LangChain's consistent interface allows you to work with various AI providers and local models.

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

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