Golang + AI + RAG Architecture

I have previously published my AI experiments using Java and Python. Curious to explore AI integration in Golang, I decided to experiment with it. Typically, Java is used for building enterprise applications, while Python is preferred for AI and Machine Learning (ML) capabilities. Golang, on the other hand, offers several advantages that make it a strong candidate for AI integration:

1. Performance

Go is a compiled language, meaning it runs directly on the hardware without an interpreter. This leads to faster execution compared to interpreted languages like Python or Ruby. It is designed to be efficient in both CPU and memory usage, making it ideal for high-performance applications.

2. Concurrency

Go has built-in support for concurrency through goroutines and channels. Goroutines are lightweight threads that are easy to create and manage, while channels facilitate safe communication between them. This makes Go an excellent choice for applications that require handling multiple tasks simultaneously, such as web servers, microservices, and distributed systems.

3. Simplicity and Readability

Go’s syntax is simple and clean, making it easy to learn and read. This reduces the likelihood of bugs and makes the codebase easier to maintain. The language avoids complex features like inheritance and generics (until recently), making the code more straightforward and less prone to errors.

4. Cross-Platform Support

Go supports cross-compilation, allowing developers to build binaries for different operating systems and architectures from a single codebase. This is particularly useful for companies that need to deploy applications across multiple platforms.

5. Fast Compilation

Go has a fast compilation speed, improving developer productivity by reducing the time spent waiting for code to compile.

6. Static Typing and?Safety

Go is statically typed, which helps catch errors at compile time rather than runtime, leading to more reliable and predictable code. Additionally, Go includes features like garbage collection, which helps manage memory safely and reduces the risk of memory leaks.

7. DevOps and Cloud-Native Development

Go is widely used in the DevOps and cloud-native space. Popular tools like Kubernetes, Terraform, Prometheus, and etcd are written in Go, making it a natural choice for companies involved in cloud infrastructure and container orchestration.

Given these advantages, integrating AI into Go projects is an important aspect of modern software development. In this article, I demonstrate how to implement a chatbot that answers context-specific questions using the RAG (Retrieval-Augmented Generation) architecture.

GitHub Repository

GitHub Repository

Refererence

https://go.dev/blog/llmpowered

Installation

To set up the project, install the following dependencies:

go get github.com/tmc/langchaingo
go get github.com/gin-gonic/gin
go get github.com/joho/godotenv        

I used Weaviate as the vector database:

docker run -p 9035:8080 -e AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED=true semitechnologies/weaviate:latest        

A spice.pdf file is located in the root directory, which will be loaded into the vector database when the application starts.

Sample Code

import (
    "github.com/tmc/langchaingo/embeddings"
    "github.com/tmc/langchaingo/llms/openai"
    "github.com/tmc/langchaingo/schema"
    "github.com/tmc/langchaingo/vectorstores/weaviate"
    "log"
    "strings"
)        

// Initializing vector store
embeddingsClient, err := openai.New(openai.WithModel("text-embedding-ada-002"))
emb, err := embeddings.NewEmbedder(embeddingsClient)
if err != nil {
    log.Fatal(err)
}        

wvStore, _ := weaviate.New(
    weaviate.WithEmbedder(emb),
    weaviate.WithScheme("http"),
    weaviate.WithHost("localhost:9035"),
    weaviate.WithIndexName("Document"),
)        

// Store documents and their embeddings in Weaviate
var wvDocs []schema.Document
for _, doc := range docs {
    if strings.TrimSpace(doc) != "" {
        wvDocs = append(wvDocs, schema.Document{PageContent: doc})
    }
}        

log.Printf("Document batch size: %d", len(wvDocs))
batchSize := 5 // Experiment with smaller batch sizes
for i := 0; i < len(wvDocs); i += batchSize {
    end := i + batchSize
    if end > len(wvDocs) {
        end = len(wvDocs)
    }
    log.Printf("Processing: %d-%d", i, end)
    _, err := wvStore.AddDocuments(d.ctx.Context, wvDocs[i:end])
    if err != nil {
        log.Fatal(err)
    }
}        

Once the application is running, visit the following URL in a browser to interact with the chatbot:

https://localhost:8080/ui

Example Questions

• What is spice?
• Which country is the top producer of spice? (Answer: India)

Function to Search in Vector?Database

func (d *DocumentService) search(query string) (string, error) {
    docs, err := d.wvStore.SimilaritySearch(d.ctx.Context, query, 3)
    if err != nil {
        log.Fatal(err)
        return "", err
    }
    var docsContents []string
    for _, doc := range docs {
        docsContents = append(docsContents, doc.PageContent)
    }
    return strings.Join(docsContents, "\n"), nil
}        

Building the?LLM

llm, err := openai.New()
if err != nil {
    log.Fatal(err)
    return nil, err
}        

Constructing the?Response

docsContents, _ := s.doc.search(query)
context := fmt.Sprintf(systemMessage, docsContents)
content := []llms.MessageContent{
    llms.TextParts(llms.ChatMessageTypeSystem, context),
    llms.TextParts(llms.ChatMessageTypeHuman, query),
}        

System Message

const systemMessage = `
I will ask you a question and will provide some additional context information.
Assume this context information is factual and correct, as part of internal
documentation.
If the question relates to the context, answer it using the context.
If the question does not relate to the context, answer it as normal.

For example, let's say the context has nothing in it about tropical flowers;
then if I ask you about tropical flowers, just answer what you know about them
without referring to the context.

For example, if the context does mention minerology and I ask you about that,
provide information from the context along with general knowledge.

Context:
%s
`        

Forwarding the Query to?LLM

completion, err := llm.GenerateContent(s.ctx.Context, content, llms.WithStreamingFunc(func(ctx context.Context, chunk []byte) error {
    fmt.Fprintf(c.Writer, string(chunk))
    c.Writer.Flush()
    return nil
}))
if err != nil {
    log.Fatal(err)
}
_ = completion        

Conclusion

Integrating AI into Golang applications using the RAG architecture provides a powerful way to enhance software with intelligent, context-aware responses. With its strong performance, concurrency, and scalability, Go is well-suited for AI-driven applications. This experiment demonstrates that Golang, coupled with tools like Weaviate and Langchaingo, can be effectively used to build AI-powered solutions. As the AI landscape continues to evolve, Golang’s efficiency and simplicity make it a promising language for future AI developments.

#Golang #ArtificialIntelligence #MachineLearning #AIIntegration #RAGArchitecture #Chatbot #LangChainGo #Weaviate #GoLangAI