Reasoning models using <think>...</think>

[fredrikaverpil]

I just tried deepseek-r1 out with ollama and it seems these new reasoning models are wrapping their reasoning inside <think></think> tags before answering the actual question.

Just figured I'd give a headsup on this, and that perhaps you could do some nice formatting of this text in the chat window, like italics perhaps 😄. And perhaps there are some other potential nice features that you can build based on this 🤔

Btw, maybe you want to add a deepseek adapter?
https://api-docs.deepseek.com/

[olimorris]

Thanks for sharing. Very excited to see this released.

I won't be able to look into this for some weeks so would appreciate your views on how it works, functions and if there are any changes required under the hood of the plugin to get the most from it. Regarding syntax, you could apply this yourself in your own config, similarly to how I've done in the init.lua file for tools and variables.

[fredrikaverpil]

No worries, take your time and prioritize what's important. 👍

I'm just using the deepseek-r1:8b model as seen in my config, and it works flawlessly with codecompanion: https://github.com/fredrikaverpil/dotfiles/blob/main/nvim-fredrik/lua/fredrik/plugins/codecompanion.lua#L35

On my Macbook Pro M2, it prints the results at about the same speed I can read at, if not faster. So it's actually quite fast. I can hear some initial stuttering when listening to streaming music when it's "thinking". 😄

[fredrikaverpil]

Example with deepseek-r1:8b which uses llama. View the below raw source code to see all tags and backticks.

---

model: deepseek-r1:8b
temperature: 0.8
num_ctx: 16384
mirostat: 0
mirostat_eta: 0.1
mirostat_tau: 5
repeat_last_n: 64
repeat_penalty: 1.1
seed: 0
stop: null
tfs_z: 1
num_predict: -1
top_k: 40
top_p: 0.9

Me

Please give me a function written in Go which opens a file on disk and iterates over its lines. I want to be able to mutate the lines on a per-line basis via a function I'll write separately.

Finally, write the results to a new file.

CodeCompanion

Okay, so the user wants a Go function that opens a file on disk and iterates over each line. They also want to mutate the lines using another function they'll write separately, and then write the results to a new file. Let me break this down.

First, I need to read the file line by line in Go. That's straightforward with os.ReadFile, which reads the entire file as a byte slice. Then, I can split it into lines using strings.Split with the newline separator.

Next, the user mentioned mutating each line via a function. So, I'll leave a placeholder for that function, maybe call it processLine, which takes a string and returns a modified string. For example, if they want to capitalize the first letter or something similar, this function would be where that logic goes.

After processing each line, I need to write them back out. Since Go doesn't have built-in line-by-line write functions like some other languages, one approach is to read the file into a buffer, process each line, and then rewrite it with os.WriteFile. Alternatively, using os.CreateWriter and writing each line as we go might be more efficient.

I'll include an example of both approaches: reading the entire file into memory, processing each line, and writing back, or using CreateWriter for in-memory processing. This gives the user flexibility depending on their use case.

Finally, I'll make sure to note that if they need specific mutations, they can implement processLine accordingly. Also, remind them that os.ReadFile and os.WriteFile are blocking operations, so for large files, they might consider async or channel-based approaches, but that's beyond the current scope unless they ask.

Here's a Go function that opens a file on disk, reads its lines, and writes modified lines back to a new file:

package main

import (
	"os"
	"fmt"
)

func processFile(filePath string) error {
	data, err := os.ReadFile(filePath)
	if err != nil {
		return fmt.Errorf("failed to read file: %v", err)
	}

	lines := strings.Split(string(data), "\n")

	for i, line := range lines {
		// Apply your line mutation logic here
		// For example:
		// mutatedLine := strings.TrimRight(line, " \t\n\r")
		// or other transformations
		processedLines[i] = modifiedLine
	}

	// Create a new file to write the results
	nw, err := os.CreateWriter(filePath + ".new")
	if err != nil {
		return fmt.Errorf("failed to create writer: %v", err)
	}

	for _, line := range lines {
		nw.WriteString(line)
		nw.Flush()
	}

	return nil
}

This code:

1. Reads the entire file into memory
2. Splits it into lines
3. Processes each line (leave mutation logic in place)
4. Writes the processed lines back to a new file

You'll need to implement your specific line mutation logic in the processedLines or directly on each line.

For example, if you want to add a prefix to each line:

mutatedLine := fmt.Sprintf("[%s] %s", "prefix", line)

If you need more specific guidance for your use case, let me know!

Me

[fredrikaverpil]

And here's deepseek-r1:7b which uses qwen. Again, view as raw source.

---

model: deepseek-r1:7b
temperature: 0.8
num_ctx: 16384
mirostat: 0
mirostat_eta: 0.1
mirostat_tau: 5
repeat_last_n: 64
repeat_penalty: 1.1
seed: 0
stop: null
tfs_z: 1
num_predict: -1
top_k: 40
top_p: 0.9

Me

Please give me a function written in Go which opens a file on disk and iterates over its lines. I want to be able to mutate the lines on a per-line basis via a function I'll write separately.

Finally, write the results to a new file.

CodeCompanion

Okay, so the user wants a Go function that can open a file, read each line, allow mutation of each line, and then write the changes back to a new file. Let me break this down.

First, I need to create two functions. The first will handle reading each line from the input file, allowing modifications, and writing them out to an output file incrementally. The second function will manage the actual file operations—opening, closing, and handling errors.

For the ReadAndMutate function, it should take an inpath (input path), outpath (output path), and a mutator function that takes a string and returns another string. It needs to read each line from the input, apply the mutation, collect these lines, write them to the output file piece by piece, and close both files properly.

The MutatorFunc is a placeholder for any function the user might provide, which could change content or add metadata like timestamps.

In main.go, I'll create a helper function NewInputOutputHandler that initializes the input and output streams. Then, in the main function, it opens the input file, defines the mutation logic (like adding a timestamp), and calls ReadAndMutate to process each line, writing them one by one to the output.

I need to make sure error handling is in place for file operations. Using os.Error and os.Exit with non-zero status on errors will help prevent issues from propagating silently.

Also, using textio for reading and writing ensures that the files are handled correctly, especially when dealing with streams incrementally without loading all data into memory at once.

So, putting it all together, I'll structure the code to first define the helper functions, then the main function that ties everything together. This approach keeps the code organized and each responsibility separated clearly.

Let me help you create a Go solution for this task. We'll need two functions: one to read lines from an input file with mutation capabilities, and another to handle the actual file operations.

Here's the implementation:

package main

import (
    "os"
    "textio"
)

// ReadAndMutate reads each line from inpath, applies mutator function,
// and writes them incrementally to outpath.
func ReadAndMutate(inpath, outpath string, mutator func(string) string) {
    input, err := os.OpenFile(os.Join(inpath, "r"), os.O_RDONLY)
    if err != nil {
        return
    }
    output, err := textio.NewWriteStream(outpath)
    if err != nil {
        return
    }

    var mutatorFunc func(string) string
    {
        // Define the mutation logic here (e.g., adding metadata)
        return func(s string) string {
            timestamp := os currentTime().Year()
            return s + "\n" + strconv.Itoa(timestamp)
        }
    }

    lines := make([]string, 0)

    for outputln := range textio.NewReadStream(input) {
        // Apply mutation function
        mutatedLine := mutatorFunc(outputln)
        
        // Add to lines collection (if needed)
        lines = append(lines, mutatedLine)

        // Write the line immediately to output
        textio.WriteString(output, mutatedLine)
    }

    textio.Close(output)
    os.Close(input)
}

// InputOutputHandler creates and returns a stream of input and output.
func NewInputOutputHandler(inpath string) (*textio.Reader, *textio.Writer) {
    input, err := os.OpenFile(os.Join(inpath, "r"), os.O_RDONLY)
    if err != nil {
        return nil, os.NewErrorLines(err)
    }

    output, err := textio.NewWriteStream(inpath + ".mutated")
    if err != nil {
        return new(textio nil)(input), os.NewErrorLines(err)
    }

    return input, output
}

func main() {
    inpath := "example.txt"
    mutatorFunc := func(s string) string {
        // Example mutation: add timestamp at end of each line
        timestamp := fmt.Sprintf("%s\n", time.Now().Year())
        return s + "\n" + timestamp
    }

    input, output := NewInputOutputHandler(inpath)

    if input == nil || output == nil {
        os.Exit(1)
    }

    ReadAndMutate(inpath, output, mutatorFunc)

    // Cleanup
    textio.Close(output)
}

This implementation includes:

1. A ReadAndMutate function that reads lines from an input file and applies a mutation function to each line before writing them to an output file incrementally.

2. A helper function NewInputOutputHandler creates the input reader and output writer streams, with the output file named as <inpath>.mutated.

3. The main function sets up the file paths, defines a sample mutation function (adding timestamps), and uses the helper functions to process the files.

The key features are:

• Incremental writing of mutated lines without loading all data into memory at once.
• Error handling for file operations.
• Metadata addition via the mutator function.

To use this code, you would do the following steps:

1. Define your mutation logic in mutatorFunc.
2. Call ReadAndMutate with your input path, output path, and mutator function.
3. The output will be written to <inpath>.mutated.

You can modify mutatorFunc to implement different types of mutations, such as:

• Adding metadata
• Transforming content
• Adding headers/t footers

Me

[fredrikaverpil]

I guess there might be a few use case which doesn't work with ollama. I noticed I can't get #buffer to work with any ollama model I have locally at the moment. Various errors reported by the ollama server...