Merge remote-tracking branch 'origin/main'

2025-05-15 03:47:13 +02:00 · 2024-07-13 11:51:09 +05:30 · 2024-07-13 11:51:09 +05:30 · d8a703503a
commit d8a703503a
parent dd9ba7c937 cf52c9610c
17 changed files with 1046 additions and 495 deletions
--- a/README.md
+++ b/README.md
@ -1,3 +1,5 @@
+<div style="text-align: center">
+
 ### Ollama4j

 <img src='https://raw.githubusercontent.com/amithkoujalgi/ollama4j/65a9d526150da8fcd98e2af6a164f055572bf722/ollama4j.jpeg' width='100' alt="ollama4j-icon">
@ -9,16 +11,28 @@ Find more details on the [website](https://amithkoujalgi.github.io/ollama4j/).
 ![GitHub stars](https://img.shields.io/github/stars/amithkoujalgi/ollama4j)
 ![GitHub forks](https://img.shields.io/github/forks/amithkoujalgi/ollama4j)
 ![GitHub watchers](https://img.shields.io/github/watchers/amithkoujalgi/ollama4j)
+![Contributors](https://img.shields.io/github/contributors/amithkoujalgi/ollama4j)
+![GitHub License](https://img.shields.io/github/license/amithkoujalgi/ollama4j)
+
 ![GitHub repo size](https://img.shields.io/github/repo-size/amithkoujalgi/ollama4j)
-![GitHub language count](https://img.shields.io/github/languages/count/amithkoujalgi/ollama4j)
 ![GitHub top language](https://img.shields.io/github/languages/top/amithkoujalgi/ollama4j)
 ![GitHub last commit](https://img.shields.io/github/last-commit/amithkoujalgi/ollama4j?color=green)
-![Hits](https://hits.seeyoufarm.com/api/count/incr/badge.svg?url=https%3A%2F%2Fgithub.com%2Famithkoujalgi%2Follama4j&count_bg=%2379C83D&title_bg=%23555555&icon=&icon_color=%23E7E7E7&title=hits&edge_flat=false)
-
 [![codecov](https://codecov.io/gh/amithkoujalgi/ollama4j/graph/badge.svg?token=U0TE7BGP8L)](https://codecov.io/gh/amithkoujalgi/ollama4j)

+![GitHub Issues or Pull Requests](https://img.shields.io/github/issues-raw/amithkoujalgi/ollama4j)
+![GitHub Issues or Pull Requests](https://img.shields.io/github/issues-closed-raw/amithkoujalgi/ollama4j)
+![GitHub Issues or Pull Requests](https://img.shields.io/github/issues-pr-raw/amithkoujalgi/ollama4j)
+![GitHub Issues or Pull Requests](https://img.shields.io/github/issues-pr-closed-raw/amithkoujalgi/ollama4j)
+![GitHub Discussions](https://img.shields.io/github/discussions/amithkoujalgi/ollama4j)
+
 ![Build Status](https://github.com/amithkoujalgi/ollama4j/actions/workflows/maven-publish.yml/badge.svg)

+</div>
+
+[//]: # (![Hits]&#40;https://hits.seeyoufarm.com/api/count/incr/badge.svg?url=https%3A%2F%2Fgithub.com%2Famithkoujalgi%2Follama4j&count_bg=%2379C83D&title_bg=%23555555&icon=&icon_color=%23E7E7E7&title=hits&edge_flat=false&#41;)
+
+[//]: # (![GitHub language count]&#40;https://img.shields.io/github/languages/count/amithkoujalgi/ollama4j&#41;)
+
 ## Table of Contents

 - [How does it work?](#how-does-it-work)
@ -172,11 +186,28 @@ Contributions are most welcome! Whether it's reporting a bug, proposing an enhan
 with code - any sort
 of contribution is much appreciated.

+### References
+
+- [Ollama REST APIs](https://github.com/jmorganca/ollama/blob/main/docs/api.md)
+
 ### Credits

 The nomenclature and the icon have been adopted from the incredible [Ollama](https://ollama.ai/)
 project.

-### References

- [Ollama REST APIs](https://github.com/jmorganca/ollama/blob/main/docs/api.md)
+<div style="text-align: center">
+
+**Thanks to the amazing contributors**
+
+<a href="https://github.com/amithkoujalgi/ollama4j/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=amithkoujalgi/ollama4j" />
+</a>
+
+### Appreciate my work?
+
+<a href="https://www.buymeacoffee.com/amithkoujalgi" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" style="height: 60px !important;width: 217px !important;" ></a>
+
+
+</div>
+
--- a/docs/docs/apis-generate/generate-async.md
+++ b/docs/docs/apis-generate/generate-async.md
@ -1,5 +1,5 @@
 ---
-sidebar_position: 2
+sidebar_position: 3
 ---

 # Generate - Async
--- a/docs/docs/apis-generate/generate-with-image-files.md
+++ b/docs/docs/apis-generate/generate-with-image-files.md
@ -1,5 +1,5 @@
 ---
-sidebar_position: 3
+sidebar_position: 4
 ---

 # Generate - With Image Files
--- a/docs/docs/apis-generate/generate-with-image-urls.md
+++ b/docs/docs/apis-generate/generate-with-image-urls.md
@ -1,5 +1,5 @@
 ---
-sidebar_position: 4
+sidebar_position: 5
 ---

 # Generate - With Image URLs
--- a/docs/docs/apis-generate/generate-with-tools.md
+++ b/docs/docs/apis-generate/generate-with-tools.md
@ -0,0 +1,271 @@
+---
+sidebar_position: 2
+---
+
+# Generate - With Tools
+
+This API lets you perform [function calling](https://docs.mistral.ai/capabilities/function_calling/) using LLMs in a
+synchronous way.
+This API correlates to
+the [generate](https://github.com/ollama/ollama/blob/main/docs/api.md#request-raw-mode) API with `raw` mode.
+
+:::note
+
+This is an only an experimental implementation and has a very basic design.
+
+Currently, built and tested for [Mistral's latest model](https://ollama.com/library/mistral) only. We could redesign
+this
+in the future if tooling is supported for more models with a generic interaction standard from Ollama.
+
+:::
+
+### Function Calling/Tools
+
+Assume you want to call a method in your code based on the response generated from the model.
+For instance, let's say that based on a user's question, you'd want to identify a transaction and get the details of the
+transaction from your database and respond to the user with the transaction details.
+
+You could do that with ease with the `function calling` capabilities of the models by registering your `tools`.
+
+### Create Functions
+
+This function takes the arguments `location` and `fuelType` and performs an operation with these arguments and returns a
+value.
+
+```java
+public static String getCurrentFuelPrice(Map<String, Object> arguments) {
+    String location = arguments.get("location").toString();
+    String fuelType = arguments.get("fuelType").toString();
+    return "Current price of " + fuelType + " in " + location + " is Rs.103/L";
+}
+```
+
+This function takes the argument `city` and performs an operation with the argument and returns a
+value.
+
+```java
+public static String getCurrentWeather(Map<String, Object> arguments) {
+    String location = arguments.get("city").toString();
+    return "Currently " + location + "'s weather is nice.";
+}
+```
+
+### Define Tool Specifications
+
+Lets define a sample tool specification called **Fuel Price Tool** for getting the current fuel price.
+
+- Specify the function `name`, `description`, and `required` properties (`location` and `fuelType`).
+- Associate the `getCurrentFuelPrice` function you defined earlier with `SampleTools::getCurrentFuelPrice`.
+
+```java
+MistralTools.ToolSpecification fuelPriceToolSpecification = MistralTools.ToolSpecification.builder()
+        .functionName("current-fuel-price")
+        .functionDesc("Get current fuel price")
+        .props(
+                new MistralTools.PropsBuilder()
+                        .withProperty("location", MistralTools.PromptFuncDefinition.Property.builder().type("string").description("The city, e.g. New Delhi, India").required(true).build())
+                        .withProperty("fuelType", MistralTools.PromptFuncDefinition.Property.builder().type("string").description("The fuel type.").enumValues(Arrays.asList("petrol", "diesel")).required(true).build())
+                        .build()
+        )
+        .toolDefinition(SampleTools::getCurrentFuelPrice)
+        .build();
+```
+
+Lets also define a sample tool specification called **Weather Tool** for getting the current weather.
+
+- Specify the function `name`, `description`, and `required` property (`city`).
+- Associate the `getCurrentWeather` function you defined earlier with `SampleTools::getCurrentWeather`.
+
+```java
+MistralTools.ToolSpecification weatherToolSpecification = MistralTools.ToolSpecification.builder()
+        .functionName("current-weather")
+        .functionDesc("Get current weather")
+        .props(
+                new MistralTools.PropsBuilder()
+                        .withProperty("city", MistralTools.PromptFuncDefinition.Property.builder().type("string").description("The city, e.g. New Delhi, India").required(true).build())
+                        .build()
+        )
+        .toolDefinition(SampleTools::getCurrentWeather)
+        .build();
+```
+
+### Register the Tools
+
+Register the defined tools (`fuel price` and `weather`) with the OllamaAPI.
+
+```shell
+ollamaAPI.registerTool(fuelPriceToolSpecification);
+ollamaAPI.registerTool(weatherToolSpecification);
+```
+
+### Create prompt with Tools
+
+`Prompt 1`: Create a prompt asking for the petrol price in Bengaluru using the defined fuel price and weather tools.
+
+```shell
+String prompt1 = new MistralTools.PromptBuilder()
+        .withToolSpecification(fuelPriceToolSpecification)
+        .withToolSpecification(weatherToolSpecification)
+        .withPrompt("What is the petrol price in Bengaluru?")
+        .build();
+OllamaToolsResult toolsResult = ollamaAPI.generateWithTools(model, prompt1, false, new OptionsBuilder().build());
+for (Map.Entry<ToolDef, Object> r : toolsResult.getToolResults().entrySet()) {
+  System.out.printf("[Response from tool '%s']: %s%n", r.getKey().getName(), r.getValue().toString());
+}
+```
+
+Now, fire away your question to the model.
+
+You will get a response similar to:
+
+::::tip[LLM Response]
+
+[Response from tool 'current-fuel-price']: Current price of petrol in Bengaluru is Rs.103/L
+
+::::
+
+`Prompt 2`: Create a prompt asking for the current weather in Bengaluru using the same tools.
+
+```shell
+String prompt2 = new MistralTools.PromptBuilder()
+        .withToolSpecification(fuelPriceToolSpecification)
+        .withToolSpecification(weatherToolSpecification)
+        .withPrompt("What is the current weather in Bengaluru?")
+        .build();
+OllamaToolsResult toolsResult = ollamaAPI.generateWithTools(model, prompt2, false, new OptionsBuilder().build());
+for (Map.Entry<ToolDef, Object> r : toolsResult.getToolResults().entrySet()) {
+  System.out.printf("[Response from tool '%s']: %s%n", r.getKey().getName(), r.getValue().toString());
+}
+```
+
+Again, fire away your question to the model.
+
+You will get a response similar to:
+
+::::tip[LLM Response]
+
+[Response from tool 'current-weather']: Currently Bengaluru's weather is nice
+::::
+
+### Full Example
+
+```java
+
+import io.github.amithkoujalgi.ollama4j.core.OllamaAPI;
+import io.github.amithkoujalgi.ollama4j.core.exceptions.OllamaBaseException;
+import io.github.amithkoujalgi.ollama4j.core.tools.ToolDef;
+import io.github.amithkoujalgi.ollama4j.core.tools.MistralTools;
+import io.github.amithkoujalgi.ollama4j.core.tools.OllamaToolsResult;
+import io.github.amithkoujalgi.ollama4j.core.utils.OptionsBuilder;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Map;
+
+public class FunctionCallingWithMistral {
+    public static void main(String[] args) throws Exception {
+        String host = "http://localhost:11434/";
+        OllamaAPI ollamaAPI = new OllamaAPI(host);
+        ollamaAPI.setRequestTimeoutSeconds(60);
+
+        String model = "mistral";
+
+
+        MistralTools.ToolSpecification fuelPriceToolSpecification = MistralTools.ToolSpecification.builder()
+                .functionName("current-fuel-price")
+                .functionDesc("Get current fuel price")
+                .props(
+                        new MistralTools.PropsBuilder()
+                                .withProperty("location", MistralTools.PromptFuncDefinition.Property.builder().type("string").description("The city, e.g. New Delhi, India").required(true).build())
+                                .withProperty("fuelType", MistralTools.PromptFuncDefinition.Property.builder().type("string").description("The fuel type.").enumValues(Arrays.asList("petrol", "diesel")).required(true).build())
+                                .build()
+                )
+                .toolDefinition(SampleTools::getCurrentFuelPrice)
+                .build();
+
+        MistralTools.ToolSpecification weatherToolSpecification = MistralTools.ToolSpecification.builder()
+                .functionName("current-weather")
+                .functionDesc("Get current weather")
+                .props(
+                        new MistralTools.PropsBuilder()
+                                .withProperty("city", MistralTools.PromptFuncDefinition.Property.builder().type("string").description("The city, e.g. New Delhi, India").required(true).build())
+                                .build()
+                )
+                .toolDefinition(SampleTools::getCurrentWeather)
+                .build();
+
+        ollamaAPI.registerTool(fuelPriceToolSpecification);
+        ollamaAPI.registerTool(weatherToolSpecification);
+
+        String prompt1 = new MistralTools.PromptBuilder()
+                .withToolSpecification(fuelPriceToolSpecification)
+                .withToolSpecification(weatherToolSpecification)
+                .withPrompt("What is the petrol price in Bengaluru?")
+                .build();
+        String prompt2 = new MistralTools.PromptBuilder()
+                .withToolSpecification(fuelPriceToolSpecification)
+                .withToolSpecification(weatherToolSpecification)
+                .withPrompt("What is the current weather in Bengaluru?")
+                .build();
+
+        ask(ollamaAPI, model, prompt1);
+        ask(ollamaAPI, model, prompt2);
+    }
+
+    public static void ask(OllamaAPI ollamaAPI, String model, String prompt) throws OllamaBaseException, IOException, InterruptedException {
+        OllamaToolsResult toolsResult = ollamaAPI.generateWithTools(model, prompt, false, new OptionsBuilder().build());
+        for (Map.Entry<ToolDef, Object> r : toolsResult.getToolResults().entrySet()) {
+            System.out.printf("[Response from tool '%s']: %s%n", r.getKey().getName(), r.getValue().toString());
+        }
+    }
+}
+
+class SampleTools {
+    public static String getCurrentFuelPrice(Map<String, Object> arguments) {
+        String location = arguments.get("location").toString();
+        String fuelType = arguments.get("fuelType").toString();
+        return "Current price of " + fuelType + " in " + location + " is Rs.103/L";
+    }
+
+    public static String getCurrentWeather(Map<String, Object> arguments) {
+        String location = arguments.get("city").toString();
+        return "Currently " + location + "'s weather is nice.";
+    }
+}
+
+```
+
+Run this full example and you will get a response similar to:
+
+::::tip[LLM Response]
+
+[Response from tool 'current-fuel-price']: Current price of petrol in Bengaluru is Rs.103/L
+
+[Response from tool 'current-weather']: Currently Bengaluru's weather is nice
+::::
+
+### Room for improvement
+
+Instead of explicitly registering `ollamaAPI.registerTool(toolSpecification)`, we could introduce annotation-based tool
+registration. For example:
+
+```java
+
+@ToolSpec(name = "current-fuel-price", desc = "Get current fuel price")
+public String getCurrentFuelPrice(Map<String, Object> arguments) {
+    String location = arguments.get("location").toString();
+    String fuelType = arguments.get("fuelType").toString();
+    return "Current price of " + fuelType + " in " + location + " is Rs.103/L";
+}
+```
+
+Instead of passing a map of args `Map<String, Object> arguments` to the tool functions, we could support passing
+specific args separately with their data types. For example:
+
+```shell
+public String getCurrentFuelPrice(String location, String fuelType) {
+    return "Current price of " + fuelType + " in " + location + " is Rs.103/L";
+}
+```
+
+Updating async/chat APIs with support for tool-based generation. 
--- a/docs/docs/apis-generate/prompt-builder.md
+++ b/docs/docs/apis-generate/prompt-builder.md
@ -1,5 +1,5 @@
 ---
-sidebar_position: 5
+sidebar_position: 6
 ---

 # Prompt Builder
--- a/pom.xml
+++ b/pom.xml
@ -4,7 +4,7 @@

    <groupId>io.github.amithkoujalgi</groupId>
    <artifactId>ollama4j</artifactId>
-    <version>1.0.74-SNAPSHOT</version>
+    <version>1.0.78-SNAPSHOT</version>

    <name>Ollama4j</name>
    <description>Java library for interacting with Ollama API.</description>
--- a/src/main/java/io/github/amithkoujalgi/ollama4j/core/OllamaAPI.java
+++ b/src/main/java/io/github/amithkoujalgi/ollama4j/core/OllamaAPI.java
@ -10,6 +10,7 @@ import io.github.amithkoujalgi.ollama4j.core.models.embeddings.OllamaEmbeddingRe
 import io.github.amithkoujalgi.ollama4j.core.models.embeddings.OllamaEmbeddingsRequestModel;
 import io.github.amithkoujalgi.ollama4j.core.models.generate.OllamaGenerateRequestModel;
 import io.github.amithkoujalgi.ollama4j.core.models.request.*;
+import io.github.amithkoujalgi.ollama4j.core.tools.*;
 import io.github.amithkoujalgi.ollama4j.core.utils.Options;
 import io.github.amithkoujalgi.ollama4j.core.utils.Utils;
 import org.slf4j.Logger;
@ -25,9 +26,7 @@ import java.net.http.HttpResponse;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.time.Duration;
-import java.util.ArrayList;
-import java.util.Base64;
-import java.util.List;
+import java.util.*;

 /**
 * The base Ollama API class.
@ -339,6 +338,7 @@ public class OllamaAPI {
        }
    }

+
    /**
     * Generate response for a question to a model running on Ollama server. This is a sync/blocking
     * call.
@ -351,9 +351,10 @@ public class OllamaAPI {
     * @param streamHandler optional callback consumer that will be applied every time a streamed response is received. If not set, the stream parameter of the request is set to false.
     * @return OllamaResult that includes response text and time taken for response
     */
-    public OllamaResult generate(String model, String prompt, Options options, OllamaStreamHandler streamHandler)
+    public OllamaResult generate(String model, String prompt, boolean raw, Options options, OllamaStreamHandler streamHandler)
            throws OllamaBaseException, IOException, InterruptedException {
        OllamaGenerateRequestModel ollamaRequestModel = new OllamaGenerateRequestModel(model, prompt);
+        ollamaRequestModel.setRaw(raw);
        ollamaRequestModel.setOptions(options.getOptionsMap());
        return generateSyncForOllamaRequestModel(ollamaRequestModel, streamHandler);
    }
@ -361,13 +362,37 @@ public class OllamaAPI {
    /**
     * Convenience method to call Ollama API without streaming responses.
     * <p>
-     * Uses {@link #generate(String, String, Options, OllamaStreamHandler)}
+     * Uses {@link #generate(String, String, boolean, Options, OllamaStreamHandler)}
+     *
+     * @param model   Model to use
+     * @param prompt  Prompt text
+     * @param raw     In some cases, you may wish to bypass the templating system and provide a full prompt. In this case, you can use the raw parameter to disable templating. Also note that raw mode will not return a context.
+     * @param options Additional Options
+     * @return OllamaResult
     */
-    public OllamaResult generate(String model, String prompt, Options options)
+    public OllamaResult generate(String model, String prompt, boolean raw, Options options)
            throws OllamaBaseException, IOException, InterruptedException {
-        return generate(model, prompt, options, null);
+        return generate(model, prompt, raw, options, null);
    }

+
+    public OllamaToolsResult generateWithTools(String model, String prompt, boolean raw, Options options)
+            throws OllamaBaseException, IOException, InterruptedException {
+        OllamaToolsResult toolResult = new OllamaToolsResult();
+        Map<ToolDef, Object> toolResults = new HashMap<>();
+
+        OllamaResult result = generate(model, prompt, raw, options, null);
+        toolResult.setModelResult(result);
+
+        List<ToolDef> toolDefs = Utils.getObjectMapper().readValue(result.getResponse(), Utils.getObjectMapper().getTypeFactory().constructCollectionType(List.class, ToolDef.class));
+        for (ToolDef toolDef : toolDefs) {
+            toolResults.put(toolDef, invokeTool(toolDef));
+        }
+        toolResult.setToolResults(toolResults);
+        return toolResult;
+    }
+
+
    /**
     * Generate response for a question to a model running on Ollama server and get a callback handle
     * that can be used to check for status and get the response from the model later. This would be
@ -377,9 +402,9 @@ public class OllamaAPI {
     * @param prompt the prompt/question text
     * @return the ollama async result callback handle
     */
-    public OllamaAsyncResultCallback generateAsync(String model, String prompt) {
+    public OllamaAsyncResultCallback generateAsync(String model, String prompt, boolean raw) {
        OllamaGenerateRequestModel ollamaRequestModel = new OllamaGenerateRequestModel(model, prompt);
-
+        ollamaRequestModel.setRaw(raw);
        URI uri = URI.create(this.host + "/api/generate");
        OllamaAsyncResultCallback ollamaAsyncResultCallback =
                new OllamaAsyncResultCallback(
@ -576,4 +601,24 @@ public class OllamaAPI {
    private boolean isBasicAuthCredentialsSet() {
        return basicAuth != null;
    }
+
+
+    public void registerTool(MistralTools.ToolSpecification toolSpecification) {
+        ToolRegistry.addFunction(toolSpecification.getFunctionName(), toolSpecification.getToolDefinition());
+    }
+
+    private Object invokeTool(ToolDef toolDef) {
+        try {
+            String methodName = toolDef.getName();
+            Map<String, Object> arguments = toolDef.getArguments();
+            DynamicFunction function = ToolRegistry.getFunction(methodName);
+            if (function == null) {
+                throw new IllegalArgumentException("No such tool: " + methodName);
+            }
+            return function.apply(arguments);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return "Error calling tool: " + e.getMessage();
+        }
+    }
 }
--- a/src/main/java/io/github/amithkoujalgi/ollama4j/core/models/request/OllamaGenerateEndpointCaller.java
+++ b/src/main/java/io/github/amithkoujalgi/ollama4j/core/models/request/OllamaGenerateEndpointCaller.java
@ -1,9 +1,5 @@
 package io.github.amithkoujalgi.ollama4j.core.models.request;

-import java.io.IOException;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.fasterxml.jackson.core.JsonProcessingException;
 import io.github.amithkoujalgi.ollama4j.core.OllamaStreamHandler;
 import io.github.amithkoujalgi.ollama4j.core.exceptions.OllamaBaseException;
@ -13,6 +9,10 @@ import io.github.amithkoujalgi.ollama4j.core.models.generate.OllamaGenerateRespo
 import io.github.amithkoujalgi.ollama4j.core.models.generate.OllamaGenerateStreamObserver;
 import io.github.amithkoujalgi.ollama4j.core.utils.OllamaRequestBody;
 import io.github.amithkoujalgi.ollama4j.core.utils.Utils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;

 public class OllamaGenerateEndpointCaller extends OllamaEndpointCaller {

@ -49,6 +49,4 @@ public class OllamaGenerateEndpointCaller extends OllamaEndpointCaller{
        streamObserver = new OllamaGenerateStreamObserver(streamHandler);
        return super.callSync(body);
    }
-    
-    
 }
--- a/src/main/java/io/github/amithkoujalgi/ollama4j/core/tools/DynamicFunction.java
+++ b/src/main/java/io/github/amithkoujalgi/ollama4j/core/tools/DynamicFunction.java
@ -0,0 +1,8 @@
+package io.github.amithkoujalgi.ollama4j.core.tools;
+
+import java.util.Map;
+
+@FunctionalInterface
+public interface DynamicFunction {
+    Object apply(Map<String, Object> arguments);
+}
--- a/src/main/java/io/github/amithkoujalgi/ollama4j/core/tools/MistralTools.java
+++ b/src/main/java/io/github/amithkoujalgi/ollama4j/core/tools/MistralTools.java
@ -0,0 +1,139 @@
+package io.github.amithkoujalgi.ollama4j.core.tools;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import io.github.amithkoujalgi.ollama4j.core.utils.Utils;
+import lombok.Builder;
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class MistralTools {
+    @Data
+    @Builder
+    public static class ToolSpecification {
+        private String functionName;
+        private String functionDesc;
+        private Map<String, PromptFuncDefinition.Property> props;
+        private DynamicFunction toolDefinition;
+    }
+
+    @Data
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    public static class PromptFuncDefinition {
+        private String type;
+        private PromptFuncSpec function;
+
+        @Data
+        public static class PromptFuncSpec {
+            private String name;
+            private String description;
+            private Parameters parameters;
+        }
+
+        @Data
+        public static class Parameters {
+            private String type;
+            private Map<String, Property> properties;
+            private List<String> required;
+        }
+
+        @Data
+        @Builder
+        public static class Property {
+            private String type;
+            private String description;
+            @JsonProperty("enum")
+            @JsonInclude(JsonInclude.Include.NON_NULL)
+            private List<String> enumValues;
+            @JsonIgnore
+            private boolean required;
+        }
+    }
+
+    public static class PropsBuilder {
+        private final Map<String, PromptFuncDefinition.Property> props = new HashMap<>();
+
+        public PropsBuilder withProperty(String key, PromptFuncDefinition.Property property) {
+            props.put(key, property);
+            return this;
+        }
+
+        public Map<String, PromptFuncDefinition.Property> build() {
+            return props;
+        }
+    }
+
+    public static class PromptBuilder {
+        private final List<PromptFuncDefinition> tools = new ArrayList<>();
+
+        private String promptText;
+
+        public String build() throws JsonProcessingException {
+            return "[AVAILABLE_TOOLS] " + Utils.getObjectMapper().writeValueAsString(tools) + "[/AVAILABLE_TOOLS][INST] " + promptText + " [/INST]";
+        }
+
+        public PromptBuilder withPrompt(String prompt) throws JsonProcessingException {
+            promptText = prompt;
+            return this;
+        }
+
+        public PromptBuilder withToolSpecification(ToolSpecification spec) {
+            PromptFuncDefinition def = new PromptFuncDefinition();
+            def.setType("function");
+
+            PromptFuncDefinition.PromptFuncSpec functionDetail = new PromptFuncDefinition.PromptFuncSpec();
+            functionDetail.setName(spec.getFunctionName());
+            functionDetail.setDescription(spec.getFunctionDesc());
+
+            PromptFuncDefinition.Parameters parameters = new PromptFuncDefinition.Parameters();
+            parameters.setType("object");
+            parameters.setProperties(spec.getProps());
+
+            List<String> requiredValues = new ArrayList<>();
+            for (Map.Entry<String, PromptFuncDefinition.Property> p : spec.getProps().entrySet()) {
+                if (p.getValue().isRequired()) {
+                    requiredValues.add(p.getKey());
+                }
+            }
+            parameters.setRequired(requiredValues);
+            functionDetail.setParameters(parameters);
+            def.setFunction(functionDetail);
+
+            tools.add(def);
+            return this;
+        }
+//
+//        public PromptBuilder withToolSpecification(String functionName, String functionDesc, Map<String, PromptFuncDefinition.Property> props) {
+//            PromptFuncDefinition def = new PromptFuncDefinition();
+//            def.setType("function");
+//
+//            PromptFuncDefinition.PromptFuncSpec functionDetail = new PromptFuncDefinition.PromptFuncSpec();
+//            functionDetail.setName(functionName);
+//            functionDetail.setDescription(functionDesc);
+//
+//            PromptFuncDefinition.Parameters parameters = new PromptFuncDefinition.Parameters();
+//            parameters.setType("object");
+//            parameters.setProperties(props);
+//
+//            List<String> requiredValues = new ArrayList<>();
+//            for (Map.Entry<String, PromptFuncDefinition.Property> p : props.entrySet()) {
+//                if (p.getValue().isRequired()) {
+//                    requiredValues.add(p.getKey());
+//                }
+//            }
+//            parameters.setRequired(requiredValues);
+//            functionDetail.setParameters(parameters);
+//            def.setFunction(functionDetail);
+//
+//            tools.add(def);
+//            return this;
+//        }
+    }
+}
--- a/src/main/java/io/github/amithkoujalgi/ollama4j/core/tools/OllamaToolsResult.java
+++ b/src/main/java/io/github/amithkoujalgi/ollama4j/core/tools/OllamaToolsResult.java
@ -0,0 +1,16 @@
+package io.github.amithkoujalgi.ollama4j.core.tools;
+
+import io.github.amithkoujalgi.ollama4j.core.models.OllamaResult;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.Map;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class OllamaToolsResult {
+    private OllamaResult modelResult;
+    private Map<ToolDef, Object> toolResults;
+}
--- a/src/main/java/io/github/amithkoujalgi/ollama4j/core/tools/ToolDef.java
+++ b/src/main/java/io/github/amithkoujalgi/ollama4j/core/tools/ToolDef.java
@ -0,0 +1,18 @@
+package io.github.amithkoujalgi.ollama4j.core.tools;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.Map;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class ToolDef {
+
+    private String name;
+    private Map<String, Object> arguments;
+
+}
+
--- a/src/main/java/io/github/amithkoujalgi/ollama4j/core/tools/ToolRegistry.java
+++ b/src/main/java/io/github/amithkoujalgi/ollama4j/core/tools/ToolRegistry.java
@ -0,0 +1,17 @@
+package io.github.amithkoujalgi.ollama4j.core.tools;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class ToolRegistry {
+    private static final Map<String, DynamicFunction> functionMap = new HashMap<>();
+
+
+    public static DynamicFunction getFunction(String name) {
+        return functionMap.get(name);
+    }
+
+    public static void addFunction(String name, DynamicFunction function) {
+        functionMap.put(name, function);
+    }
+}
--- a/src/main/java/io/github/amithkoujalgi/ollama4j/core/types/OllamaModelType.java
+++ b/src/main/java/io/github/amithkoujalgi/ollama4j/core/types/OllamaModelType.java
@ -9,6 +9,9 @@ package io.github.amithkoujalgi.ollama4j.core.types;
@SuppressWarnings("ALL")
 public class OllamaModelType {
    public static final String GEMMA = "gemma";
+    public static final String GEMMA2 = "gemma2";
+
+
    public static final String LLAMA2 = "llama2";
    public static final String LLAMA3 = "llama3";
    public static final String MISTRAL = "mistral";
@ -30,6 +33,8 @@ public class OllamaModelType {
    public static final String ZEPHYR = "zephyr";
    public static final String OPENHERMES = "openhermes";
    public static final String QWEN = "qwen";
+
+    public static final String QWEN2 = "qwen2";
    public static final String WIZARDCODER = "wizardcoder";
    public static final String LLAMA2_CHINESE = "llama2-chinese";
    public static final String TINYLLAMA = "tinyllama";
--- a/src/test/java/io/github/amithkoujalgi/ollama4j/integrationtests/TestRealAPIs.java
+++ b/src/test/java/io/github/amithkoujalgi/ollama4j/integrationtests/TestRealAPIs.java
@ -1,7 +1,5 @@
 package io.github.amithkoujalgi.ollama4j.integrationtests;

-import static org.junit.jupiter.api.Assertions.*;
-
 import io.github.amithkoujalgi.ollama4j.core.OllamaAPI;
 import io.github.amithkoujalgi.ollama4j.core.exceptions.OllamaBaseException;
 import io.github.amithkoujalgi.ollama4j.core.models.ModelDetail;
@ -10,9 +8,16 @@ import io.github.amithkoujalgi.ollama4j.core.models.chat.OllamaChatMessageRole;
 import io.github.amithkoujalgi.ollama4j.core.models.chat.OllamaChatRequestBuilder;
 import io.github.amithkoujalgi.ollama4j.core.models.chat.OllamaChatRequestModel;
 import io.github.amithkoujalgi.ollama4j.core.models.chat.OllamaChatResult;
-import io.github.amithkoujalgi.ollama4j.core.models.embeddings.OllamaEmbeddingsRequestModel;
 import io.github.amithkoujalgi.ollama4j.core.models.embeddings.OllamaEmbeddingsRequestBuilder;
+import io.github.amithkoujalgi.ollama4j.core.models.embeddings.OllamaEmbeddingsRequestModel;
 import io.github.amithkoujalgi.ollama4j.core.utils.OptionsBuilder;
+import lombok.Data;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
@ -22,12 +27,8 @@ import java.net.http.HttpConnectTimeoutException;
 import java.util.List;
 import java.util.Objects;
 import java.util.Properties;
-import lombok.Data;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Order;
-import org.junit.jupiter.api.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+
+import static org.junit.jupiter.api.Assertions.*;

 class TestRealAPIs {

@ -116,6 +117,7 @@ class TestRealAPIs {
                    ollamaAPI.generate(
                            config.getModel(),
                            "What is the capital of France? And what's France's connection with Mona Lisa?",
+                            false,
                            new OptionsBuilder().build());
            assertNotNull(result);
            assertNotNull(result.getResponse());
@ -130,11 +132,10 @@ class TestRealAPIs {
    void testAskModelWithDefaultOptionsStreamed() {
        testEndpointReachability();
        try {
-
            StringBuffer sb = new StringBuffer("");
-
            OllamaResult result = ollamaAPI.generate(config.getModel(),
                    "What is the capital of France? And what's France's connection with Mona Lisa?",
+                    false,
                    new OptionsBuilder().build(), (s) -> {
                        LOG.info(s);
                        String substring = s.substring(sb.toString().length(), s.length());
@ -160,6 +161,7 @@ class TestRealAPIs {
                    ollamaAPI.generate(
                            config.getModel(),
                            "What is the capital of France? And what's France's connection with Mona Lisa?",
+                            true,
                            new OptionsBuilder().setTemperature(0.9f).build());
            assertNotNull(result);
            assertNotNull(result.getResponse());
--- a/src/test/java/io/github/amithkoujalgi/ollama4j/unittests/TestMockedAPIs.java
+++ b/src/test/java/io/github/amithkoujalgi/ollama4j/unittests/TestMockedAPIs.java
@ -1,7 +1,5 @@
 package io.github.amithkoujalgi.ollama4j.unittests;

-import static org.mockito.Mockito.*;
-
 import io.github.amithkoujalgi.ollama4j.core.OllamaAPI;
 import io.github.amithkoujalgi.ollama4j.core.exceptions.OllamaBaseException;
 import io.github.amithkoujalgi.ollama4j.core.models.ModelDetail;
@ -9,12 +7,15 @@ import io.github.amithkoujalgi.ollama4j.core.models.OllamaAsyncResultCallback;
 import io.github.amithkoujalgi.ollama4j.core.models.OllamaResult;
 import io.github.amithkoujalgi.ollama4j.core.types.OllamaModelType;
 import io.github.amithkoujalgi.ollama4j.core.utils.OptionsBuilder;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
 import java.io.IOException;
 import java.net.URISyntaxException;
 import java.util.ArrayList;
 import java.util.Collections;
-import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
+
+import static org.mockito.Mockito.*;

 class TestMockedAPIs {
    @Test
@ -103,10 +104,10 @@ class TestMockedAPIs {
        String prompt = "some prompt text";
        OptionsBuilder optionsBuilder = new OptionsBuilder();
        try {
-      when(ollamaAPI.generate(model, prompt, optionsBuilder.build()))
+            when(ollamaAPI.generate(model, prompt, false, optionsBuilder.build()))
                    .thenReturn(new OllamaResult("", 0, 200));
-      ollamaAPI.generate(model, prompt, optionsBuilder.build());
-      verify(ollamaAPI, times(1)).generate(model, prompt, optionsBuilder.build());
+            ollamaAPI.generate(model, prompt, false, optionsBuilder.build());
+            verify(ollamaAPI, times(1)).generate(model, prompt, false, optionsBuilder.build());
        } catch (IOException | OllamaBaseException | InterruptedException e) {
            throw new RuntimeException(e);
        }
@ -155,9 +156,9 @@ class TestMockedAPIs {
        OllamaAPI ollamaAPI = Mockito.mock(OllamaAPI.class);
        String model = OllamaModelType.LLAMA2;
        String prompt = "some prompt text";
-    when(ollamaAPI.generateAsync(model, prompt))
+        when(ollamaAPI.generateAsync(model, prompt, false))
                .thenReturn(new OllamaAsyncResultCallback(null, null, 3));
-    ollamaAPI.generateAsync(model, prompt);
-    verify(ollamaAPI, times(1)).generateAsync(model, prompt);
+        ollamaAPI.generateAsync(model, prompt, false);
+        verify(ollamaAPI, times(1)).generateAsync(model, prompt, false);
    }
 }