Skip to content

Chat completion

Completion

The chat completion can be used to generate a conversational response for a given set of messages with a provided model.

 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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package main

import (
    "github.com/parakeet-nest/parakeet/completion"
    "github.com/parakeet-nest/parakeet/llm"
    "github.com/parakeet-nest/parakeet/enums/option"


    "fmt"
    "log"
)

func main() {
    ollamaUrl := "http://localhost:11434"
    model := "deepseek-coder"

    systemContent := `You are an expert in computer programming.
    Please make friendly answer for the noobs.
    Add source code examples if you can.`

    userContent := `I need a clear explanation regarding the following question:
    Can you create a "hello world" program in Golang?
    And, please, be structured with bullet points`

    options := llm.SetOptions(map[string]interface{}{
        option.Temperature: 0.5,
        option.RepeatLastN: 2,
        option.RepeatPenalty: 2.0,
    })

    query := llm.Query{
        Model: model,
        Messages: []llm.Message{
            {Role: "system", Content: systemContent},
            {Role: "user", Content: userContent},
        },
        Options: options,
        Stream: false,
    }

    answer, err := completion.Chat(ollamaUrl, query)
    if err != nil {
        log.Fatal("😡:", err)
    }
    fmt.Println(answer.Message.Content)
}

✋ To keep a conversational memory for the next chat completion, update the list of messages with the previous question and answer.

Completion with stream

 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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package main

import (
    "fmt"
    "log"

    "github.com/parakeet-nest/parakeet/completion"
    "github.com/parakeet-nest/parakeet/llm"
)

func main() {
    ollamaUrl := "http://localhost:11434"
    model := "deepseek-coder"

    systemContent := `You are an expert in computer programming.
    Please make friendly answer for the noobs.
    Add source code examples if you can.`

    userContent := `I need a clear explanation regarding the following question:
    Can you create a "hello world" program in Golang?
    And, please, be structured with bullet points`

    options := llm.Options{
        Temperature: 0.5,
        RepeatLastN: 2, 
    }

    query := llm.Query{
        Model: model,
        Messages: []llm.Message{
            {Role: "system", Content: systemContent},
            {Role: "user", Content: userContent},
        },
        Options: options,
        Stream:  false,
    }

    _, err := completion.ChatStream(ollamaUrl, query,
        func(answer llm.Answer) error {
            fmt.Print(answer.Message.Content)
            return nil
        })

    if err != nil {
        log.Fatal("😡:", err)
    }
}

Chat completion with conversational memory

In memory history

To store the messages in memory, use history.MemoryMessages

 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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
package main

import (
    "fmt"
    "log"

    "github.com/parakeet-nest/parakeet/completion"
    "github.com/parakeet-nest/parakeet/history"
    "github.com/parakeet-nest/parakeet/llm"
)

func main() {
    ollamaUrl := "http://localhost:11434"
    model := "tinydolphin" // fast, and perfect answer (short, brief)

    conversation := history.MemoryMessages{
        Messages: make(map[string]llm.MessageRecord),
    }

    systemContent := `You are an expert with the Star Trek series. use the history of the conversation to answer the question`

    userContent := `Who is James T Kirk?`

    options := llm.Options{
        Temperature: 0.5,
        RepeatLastN: 2,  
    }

    query := llm.Query{
        Model: model,
        Messages: []llm.Message{
            {Role: "system", Content: systemContent},
            {Role: "user", Content: userContent},
        },
        Options: options,
    }

    // Ask the question
    answer, err := completion.ChatStream(ollamaUrl, query,
        func(answer llm.Answer) error {
            fmt.Print(answer.Message.Content)
            return nil
        },
    )
    if err != nil {
        log.Fatal("😡:", err)
    }

    // Save the conversation
    _, err = conversation.SaveMessage("1", llm.Message{
        Role:    "user",
        Content: userContent,
    })
    if err != nil {
        log.Fatal("😡:", err)
    }

    _, err = conversation.SaveMessage("2", llm.Message{
        Role:    "system",
        Content: answer.Message.Content,
    })

    if err != nil {
        log.Fatal("😡:", err)
    }

    // New question
    userContent = `Who is his best friend ?`

    previousMessages, _ := conversation.GetAllMessages()

    // (Re)Create the conversation
    conversationMessages := []llm.Message{}
    // instruction
    conversationMessages = append(conversationMessages, llm.Message{Role: "system", Content: systemContent})
    // history
    conversationMessages = append(conversationMessages, previousMessages...)
    // last question
    conversationMessages = append(conversationMessages, llm.Message{Role: "user", Content: userContent})

    query = llm.Query{
        Model:    model,
        Messages: conversationMessages,
        Options:  options,
    }

    answer, err = completion.ChatStream(ollamaUrl, query,
        func(answer llm.Answer) error {
            fmt.Print(answer.Message.Content)
            return nil
        },
    )
    fmt.Println()
    if err != nil {
        log.Fatal("😡:", err)
    }

}

Bbolt history

Bbolt is an embedded key/value database for Go.

To store the messages in a bbolt bucket, use history.BboltMessages

1
2
conversation := history.BboltMessages{}
conversation.Initialize("../conversation.db")

Note

👀 you will find a complete example in: