8/27/2024

Implementing Singleton Pattern in Ollama

The Singleton Pattern is one of the most commonly used design patterns in programming, especially in scenarios where we need to ensure that a class has only one instance throughout the execution of a program. This is particularly useful in resource-intensive applications that utilize services like large language models (LLMs), such as those offered by Ollama. In this blog post, we'll delve deep into the implementation of the Singleton Pattern in Ollama, exploring its intricacies, benefits, and practical use cases.

What is the Singleton Pattern?

The Singleton Pattern restricts the instantiation of a class to a SINGLE instance. This means,

No unnecessary instances: Once the instance is created, the same instance is returned for any following requests.
Controlled access: Singleton ensures controlled access to the single instance without creating additional instances.
Global access point: It acts as a global access point to the instance, which can be particularly useful in various scenarios.

Benefits of the Singleton Pattern

Resource Management: Helps to manage resources efficiently, especially with large data. Using a Singleton ensures that the system resources are not overly taxed.
Controlled access: Improves data consistency and safety by ensuring all clients use the same instance.
Performance: Reduces time complexity by ensuring that only one instance exists, leading to faster access to shared resources.

Perhaps your application won't be the same without the efficiency of a Singleton for managing language models locally.

Why Ollama?

Ollama is a powerful desktop application that simplifies the process of running Large Language Models locally on your machine. It provides an easy-to-use Command Line Interface (CLI) to interact with models. It allows developers to enhance their applications, build intelligent chatbots, and conduct various experiments without needing a strong background in machine learning. But how do you utilize the Singleton Pattern while interfacing with Ollama?

Setting Up Ollama

Before diving into implementing the Singleton Pattern, ensure you have Ollama properly set up on your local machine. You will need to install Ollama following the step-by-step instructions on their website.

Pulling Model Weights

Once installed, you’ll want to pull the model weights. Using terminal, run:

1
2

bash
ollama pull <MODEL_NAME>

Model names could be

[Llama2-7B](https://ollama.ai/library/llama2)

[Mistral-7B](https://ollama.ai/library/mistral)

. Typically, it is advised to pull the model you plan to use for your application.

Command Line Setup

A simple terminal command allows you to interface with Ollama via its REST API. For instance, you could fetch streaming responses with:

1
2

bash
ollama serve

Understanding Ollama Commands

ollama pull: Fetches the model from the Ollama repository to your local device.
ollama serve: Starts the local server to allow interaction with the model.

Implementing Singleton Pattern

Next up, let’s implement the Singleton Pattern for Ollama. This is where we ensure our application uses only one instance of the Ollama model, which is resource efficient and improves performance.

Basic Skeleton of the Singleton in TypeScript

Let’s outline how our Singleton will look using TypeScript. Here’s a simple example of a Singleton class:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class OllamaSingleton {
    private static instance: OllamaSingleton | null = null;
    private modelName: string;

    private constructor(modelName: string) {
        this.modelName = modelName;
        // Initialization code for the model can go here
    }

    public static getInstance(modelName: string): OllamaSingleton {
        if (this.instance === null) {
            this.instance = new OllamaSingleton(modelName);
        }
        return this.instance;
    }
}

Explanation of the Code

Private Constructor: The constructor is private to prevent external instantiation. It allows the class to control its instantiation.
Static Instance: Holds the reference to the single instance of the class. It checks if an instance already exists and creates one if it doesn't.
Public Method: The
1getInstance
method gives controlled access to the Singleton instance, ensuring only one instance is created.

Usage of OllamaSingleton in Your Application

To use this Singleton implementation in your application:

1
2

typescript
const ollamaModel = OllamaSingleton.getInstance('mistral'); // or any model name

This ensures you only ever access your Ollama model through the instance of

OllamaSingleton

, thus respecting the Singleton Pattern principles.

Enhancing Your Singleton

Implementing the Command Interaction Logic

Once our base Singleton is implemented, we can enhance its functionality to allow interaction with the Ollama model. For instance, you might want to add methods for sending prompts and receiving responses:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class OllamaSingleton {
    private static instance: OllamaSingleton | null = null;
    private modelName: string;

    private constructor(modelName: string) {
        this.modelName = modelName;
        // Initialization code for the model can go here
    }

    public static getInstance(modelName: string): OllamaSingleton {
        if (this.instance === null) {
            this.instance = new OllamaSingleton(modelName);
        }
        return this.instance;
    }

    public async sendPrompt(prompt: string): Promise<string> {
        // Logic to interact with the Ollama model using REST API
        const response = await fetch(`http://localhost:11434/api/generate`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify({ model: this.modelName, prompt })
        });
        const data = await response.json();
        return data.result;
    }
}

With the
1sendPrompt
method, you can send a prompt string to your Ollama model and receive the generated response back.

Using the Singleton Pattern in a Real App

Imagine you are developing an intelligent chatbot that interacts with your users, answering their questions based on your enterprise-specific data or knowledge base. Given the benefits of the Singleton Pattern, all requests to your chatbot model would call this singleton rather than creating new instances repeatedly, thus saving on resources and ensuring quicker response times.

For example:

typescript
const chatBotModel = OllamaSingleton.getInstance('mistral');
const userResponse = await chatBotModel.sendPrompt('Tell me about the weather today.');
console.log(userResponse);

This guarantees that your application leverages the efficiency of the Singleton Pattern with Ollama, making interactions reliable and effective.

Closing Thoughts

The Singleton Pattern is a great fit for applications where control over access to shared resources is critical, such as when interfacing with services like Ollama and their localized models. By keeping a single model instance, you enhance performance, reduce resource consumption, and make scaling easier. Remember, utilizing the power of Ollama is all about making intelligent decisions—start with the Singleton Pattern to streamline your interactions, and the results will certainly reflect this efficiency.

Want your own custom chatbot? Check out Arsturn where you can instantly create custom ChatGPT chatbots tailored to your specific needs—without breaking a sweat! With Arsturn, you can boost engagement and increase conversions while unlocking the power of AI to directly connect with your audience! Get started today, with no credit card required!

Join the Conversation

Have you implemented the Singleton Pattern with Ollama or other models? Share your experiences or ask questions in the comments below! Let's keep the conversation going on best practices and innovative approaches!