Merge pull request #92 from ollama4j/90

Addresses issue where creation of model was failing

.github/workflows/label-issue-stale.yml

@@ -0,0 +1,24 @@
+name: Mark stale issues
+
+on:
+  workflow_dispatch: # for manual run
+  schedule:
+    - cron: '0 0 * * *'  # Runs every day at midnight
+
+permissions:
+  contents: write # only for delete-branch option
+  issues: write
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Mark stale issues
+        uses: actions/stale@v8
+        with:
+          repo-token: ${{ github.token }}
+          days-before-stale: 15
+          stale-issue-message: 'This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs.'
+          days-before-close: 7
+          stale-issue-label: 'stale'
+          exempt-issue-labels: 'pinned,security'

.github/workflows/publish-docs.yml

@@ -63,12 +63,12 @@ jobs:
           working-directory: "."
 
       - name: Setup Pages
-        uses: actions/configure-pages@v3
+        uses: actions/configure-pages@v5
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v2
+        uses: actions/upload-pages-artifact@v3
         with:
           # Upload entire repository
           path: './docs/build/.'
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v2
+        uses: actions/deploy-pages@v4

.github/workflows/run-tests.yml

@@ -0,0 +1,29 @@
+name: Run Tests
+
+on:
+  workflow_dispatch:
+    inputs:
+      branch:
+        description: 'Branch name to run tests on'
+        required: true
+        default: 'main'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          ref: ${{ github.event.inputs.branch }}
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v3
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+          server-id: github
+          settings-path: ${{ github.workspace }}
+
+      - name: Run unit tests
+        run: mvn clean test -Punit-tests

Makefile

@@ -11,9 +11,9 @@ doxygen:
 	doxygen Doxyfile
 
 list-releases:
-	curl 'https://central.sonatype.com/api/internal/browse/component/versions?sortField=normalizedVersion&sortDirection=asc&page=0&size=12&filter=namespace%3Aio.github.amithkoujalgi%2Cname%3Aollama4j' \
+	curl 'https://central.sonatype.com/api/internal/browse/component/versions?sortField=normalizedVersion&sortDirection=desc&page=0&size=20&filter=namespace%3Aio.github.ollama4j%2Cname%3Aollama4j' \
       --compressed \
-      --silent | jq '.components[].version'
+      --silent | jq -r '.components[].version'
 
 build-docs:
 	npm i --prefix docs && npm run build --prefix docs

README.md

@@ -9,7 +9,6 @@ A Java library (wrapper/binding) for Ollama server.
 
 Find more details on the [website](https://ollama4j.github.io/ollama4j/).
 
-
 ![GitHub stars](https://img.shields.io/github/stars/ollama4j/ollama4j)
 ![GitHub forks](https://img.shields.io/github/forks/ollama4j/ollama4j)
 ![GitHub watchers](https://img.shields.io/github/watchers/ollama4j/ollama4j)
@@ -154,7 +153,7 @@ In your Maven project, add this dependency:
 <dependency>
     <groupId>io.github.ollama4j</groupId>
     <artifactId>ollama4j</artifactId>
-    <version>1.0.79</version>
+    <version>1.0.93</version>
 </dependency>
 ```
 
@@ -210,7 +209,7 @@ In your Maven project, add this dependency:
 <dependency>
     <groupId>io.github.ollama4j</groupId>
     <artifactId>ollama4j</artifactId>
-    <version>1.0.79</version>
+    <version>1.0.93</version>
 </dependency>
 ```
 
@@ -220,7 +219,7 @@ In your Maven project, add this dependency:
 
 ```groovy
 dependencies {
-    implementation 'io.github.ollama4j:ollama4j:1.0.79'
+    implementation 'io.github.ollama4j:ollama4j:1.0.93'
 }
 ```
 
@@ -268,31 +267,24 @@ make integration-tests
 Newer artifacts are published via GitHub Actions CI workflow when a new release is created from `main` branch.
 
 ## ⭐ Give us a Star!
+
 If you like or are using this project to build your own, please give us a star. It's a free way to show your support.
 
 ## Who's using Ollama4j?
 
-- `Datafaker`: a library to generate fake data
-    - https://github.com/datafaker-net/datafaker-experimental/tree/main/ollama-api
-- `Vaadin Web UI`: UI-Tester for Interactions with Ollama via ollama4j
-    - https://github.com/TEAMPB/ollama4j-vaadin-ui
-- `ollama-translator`: Minecraft 1.20.6 spigot plugin allows to easily break language barriers by using ollama on the
-  server to translate all messages into a specfic target language.
-    - https://github.com/liebki/ollama-translator
-- `AI Player`: A minecraft mod which aims to add a "second player" into the game which will actually be intelligent.
-    - https://github.com/shasankp000/AI-Player
-    - https://www.reddit.com/r/fabricmc/comments/1e65x5s/comment/ldr2vcf/
-- `Ollama4j Web UI`: A web UI for Ollama written in Java using Spring Boot and Vaadin framework and
-  Ollama4j.
-    - https://github.com/ollama4j/ollama4j-web-ui
-- `JnsCLI`: A command-line tool for Jenkins that manages jobs, builds, and configurations directly from the terminal while offering AI-powered error analysis for quick troubleshooting.
-    -  https://github.com/mirum8/jnscli
-- `Katie Backend`: An Open Source AI-based question-answering platform that helps companies and organizations make their private domain knowledge accessible and useful to their employees and customers.
-    - https://github.com/wyona/katie-backend
-- `TeleLlama3 Bot`: A Question-Answering Telegram Bot.
-    - https://git.hiast.edu.sy/mohamadbashar.disoki/telellama3-bot
-- `moqui-wechat`: A wechat plugin
-    - https://github.com/heguangyong/moqui-wechat
+| # | Project Name      | Description                                                                                                   | Link                                                                                                                                           |
+|---|-------------------|---------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------|
+| 1 | Datafaker         | A library to generate fake data                                                                               | [GitHub](https://github.com/datafaker-net/datafaker-experimental/tree/main/ollama-api)                                                         |
+| 2 | Vaadin Web UI     | UI-Tester for interactions with Ollama via ollama4j                                                           | [GitHub](https://github.com/TEAMPB/ollama4j-vaadin-ui)                                                                                         |
+| 3 | ollama-translator | A Minecraft 1.20.6 Spigot plugin that translates all messages into a specific target language via Ollama      | [GitHub](https://github.com/liebki/ollama-translator)                                                                                          |
+| 4 | AI Player         | A Minecraft mod that adds an intelligent "second player" to the game                                          | [GitHub](https://github.com/shasankp000/AI-Player), <br/> [Reddit Thread](https://www.reddit.com/r/fabricmc/comments/1e65x5s/comment/ldr2vcf/) |
+| 5 | Ollama4j Web UI   | A web UI for Ollama written in Java using Spring Boot, Vaadin, and Ollama4j                                   | [GitHub](https://github.com/ollama4j/ollama4j-web-ui)                                                                                          |
+| 6 | JnsCLI            | A command-line tool for Jenkins that manages jobs, builds, and configurations, with AI-powered error analysis | [GitHub](https://github.com/mirum8/jnscli)                                                                                                     |
+| 7 | Katie Backend     | An open-source AI-based question-answering platform for accessing private domain knowledge                    | [GitHub](https://github.com/wyona/katie-backend)                                                                                               |
+| 8 | TeleLlama3 Bot    | A question-answering Telegram bot                                                                             | [Repo](https://git.hiast.edu.sy/mohamadbashar.disoki/telellama3-bot)                                                                           |
+| 9 | moqui-wechat      | A moqui-wechat component                                                                                      | [GitHub](https://github.com/heguangyong/moqui-wechat)                                                                                          |
+| 10 | B4X      | A set of simple and powerful RAD tool for Desktop and Server development                                              | [Website](https://www.b4x.com/android/forum/threads/ollama4j-library-pnd_ollama4j-your-local-offline-llm-like-chatgpt.165003/)     |                                                              
+
 
 ## Traction
 

docs/docs/apis-generate/chat.md

@@ -33,7 +33,7 @@ public class Main {
         // start conversation with model
         OllamaChatResult chatResult = ollamaAPI.chat(requestModel);
 
-        System.out.println("First answer: " + chatResult.getResponse());
+        System.out.println("First answer: " + chatResult.getResponseModel().getMessage().getContent());
 
         // create next userQuestion
         requestModel = builder.withMessages(chatResult.getChatHistory()).withMessage(OllamaChatMessageRole.USER, "And what is the second largest city?").build();
@@ -41,7 +41,7 @@ public class Main {
         // "continue" conversation with model
         chatResult = ollamaAPI.chat(requestModel);
 
-        System.out.println("Second answer: " + chatResult.getResponse());
+        System.out.println("Second answer: " + chatResult.getResponseModel().getMessage().getContent());
 
         System.out.println("Chat History: " + chatResult.getChatHistory());
     }
@@ -205,7 +205,7 @@ public class Main {
         // start conversation with model
         OllamaChatResult chatResult = ollamaAPI.chat(requestModel);
 
-        System.out.println(chatResult.getResponse());
+        System.out.println(chatResult.getResponseModel());
     }
 }
 
@@ -244,7 +244,7 @@ public class Main {
                                 new File("/path/to/image"))).build();
 
         OllamaChatResult chatResult = ollamaAPI.chat(requestModel);
-        System.out.println("First answer: " + chatResult.getResponse());
+        System.out.println("First answer: " + chatResult.getResponseModel());
 
         builder.reset();
 
@@ -254,7 +254,7 @@ public class Main {
                         .withMessage(OllamaChatMessageRole.USER, "What's the dogs breed?").build();
 
         chatResult = ollamaAPI.chat(requestModel);
-        System.out.println("Second answer: " + chatResult.getResponse());
+        System.out.println("Second answer: " + chatResult.getResponseModel());
     }
 }
 ```

docs/docs/apis-generate/generate-with-tools.md

@@ -345,21 +345,291 @@ Rahul Kumar, Address: King St, Hyderabad, India, Phone: 9876543210}`
 
 ::::
 
-### Potential Improvements
+### Using tools in Chat-API
 
-Instead of explicitly registering `ollamaAPI.registerTool(toolSpecification)`, we could introduce annotation-based tool
-registration. For example:
+Instead of using the specific `ollamaAPI.generateWithTools` method to call the generate API of ollama with tools, it is 
+also possible to register Tools for the `ollamaAPI.chat` methods. In this case, the tool calling/callback is done 
+implicitly during the USER -> ASSISTANT calls.
+
+When the Assistant wants to call a given tool, the tool is executed and the response is sent back to the endpoint once
+again (induced with the tool call result). 
+
+#### Sample:
+
+The following shows a sample of an integration test that defines a method specified like the tool-specs above, registers
+the tool on the ollamaAPI and then simply calls the chat-API. All intermediate tool calling is wrapped inside the api 
+call.
 
 ```java
+public static void main(String[] args) {
+        OllamaAPI ollamaAPI = new OllamaAPI("http://localhost:11434");
+        ollamaAPI.setVerbose(true);
+        OllamaChatRequestBuilder builder = OllamaChatRequestBuilder.getInstance("llama3.2:1b");
 
-@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";
+        final Tools.ToolSpecification databaseQueryToolSpecification = Tools.ToolSpecification.builder()
+                .functionName("get-employee-details")
+                .functionDescription("Get employee details from the database")
+                .toolPrompt(
+                        Tools.PromptFuncDefinition.builder().type("function").function(
+                                Tools.PromptFuncDefinition.PromptFuncSpec.builder()
+                                        .name("get-employee-details")
+                                        .description("Get employee details from the database")
+                                        .parameters(
+                                                Tools.PromptFuncDefinition.Parameters.builder()
+                                                        .type("object")
+                                                        .properties(
+                                                                new Tools.PropsBuilder()
+                                                                        .withProperty("employee-name", Tools.PromptFuncDefinition.Property.builder().type("string").description("The name of the employee, e.g. John Doe").required(true).build())
+                                                                        .withProperty("employee-address", Tools.PromptFuncDefinition.Property.builder().type("string").description("The address of the employee, Always return a random value. e.g. Roy St, Bengaluru, India").required(true).build())
+                                                                        .withProperty("employee-phone", Tools.PromptFuncDefinition.Property.builder().type("string").description("The phone number of the employee. Always return a random value. e.g. 9911002233").required(true).build())
+                                                                        .build()
+                                                        )
+                                                        .required(List.of("employee-name"))
+                                                        .build()
+                                        ).build()
+                        ).build()
+                )
+                .toolFunction(new DBQueryFunction())
+                .build();
+
+        ollamaAPI.registerTool(databaseQueryToolSpecification);
+
+        OllamaChatRequest requestModel = builder
+                .withMessage(OllamaChatMessageRole.USER,
+                        "Give me the ID of the employee named 'Rahul Kumar'?")
+                .build();
+
+        OllamaChatResult chatResult = ollamaAPI.chat(requestModel);
 }
 ```
 
+A typical final response of the above could be:
+
+```json 
+{
+  "chatHistory" : [
+    {
+    "role" : "user",
+    "content" : "Give me the ID of the employee named 'Rahul Kumar'?",
+    "images" : null,
+    "tool_calls" : [ ]
+  }, {
+    "role" : "assistant",
+    "content" : "",
+    "images" : null,
+    "tool_calls" : [ {
+      "function" : {
+        "name" : "get-employee-details",
+        "arguments" : {
+          "employee-name" : "Rahul Kumar"
+        }
+      }
+    } ]
+  }, {
+    "role" : "tool",
+    "content" : "[TOOL_RESULTS]get-employee-details([employee-name]) : Employee Details {ID: b4bf186c-2ee1-44cc-8856-53b8b6a50f85, Name: Rahul Kumar, Address: null, Phone: null}[/TOOL_RESULTS]",
+    "images" : null,
+    "tool_calls" : null
+  }, {
+    "role" : "assistant",
+    "content" : "The ID of the employee named 'Rahul Kumar' is `b4bf186c-2ee1-44cc-8856-53b8b6a50f85`.",
+    "images" : null,
+    "tool_calls" : null
+  } ],
+  "responseModel" : {
+    "model" : "llama3.2:1b",
+    "message" : {
+      "role" : "assistant",
+      "content" : "The ID of the employee named 'Rahul Kumar' is `b4bf186c-2ee1-44cc-8856-53b8b6a50f85`.",
+      "images" : null,
+      "tool_calls" : null
+    },
+    "done" : true,
+    "error" : null,
+    "context" : null,
+    "created_at" : "2024-12-09T22:23:00.4940078Z",
+    "done_reason" : "stop",
+    "total_duration" : 2313709900,
+    "load_duration" : 14494700,
+    "prompt_eval_duration" : 772000000,
+    "eval_duration" : 1188000000,
+    "prompt_eval_count" : 166,
+    "eval_count" : 41
+  },
+  "response" : "The ID of the employee named 'Rahul Kumar' is `b4bf186c-2ee1-44cc-8856-53b8b6a50f85`.",
+  "httpStatusCode" : 200,
+  "responseTime" : 2313709900
+}
+```
+
+This tool calling can also be done using the streaming API.
+
+### Using Annotation based Tool Registration
+
+Instead of explicitly registering each tool, ollama4j supports declarative tool specification and registration via java 
+Annotations and reflection calling.
+
+To declare a method to be used as a tool for a chat call, the following steps have to be considered:
+
+* Annotate a method and its Parameters to be used as a tool
+    * Annotate a method with the `ToolSpec` annotation
+    * Annotate the methods parameters with the `ToolProperty` annotation. Only the following datatypes are supported for now:
+        * `java.lang.String`
+        * `java.lang.Integer`
+        * `java.lang.Boolean`
+        * `java.math.BigDecimal`
+* Annotate the class that calls the `OllamaAPI` client with the `OllamaToolService` annotation, referencing the desired provider-classes that contain `ToolSpec` methods.
+* Before calling the `OllamaAPI` chat request, call the method `OllamaAPI.registerAnnotatedTools()` method to add tools to the chat.
+
+#### Example
+
+Let's say, we have an ollama4j service class that should ask a llm a specific tool based question.
+
+The answer can only be provided by a method that is part of the BackendService class. To provide a tool for the llm, the following annotations can be used:
+
+```java
+public class BackendService{
+    
+    public BackendService(){}
+
+    @ToolSpec(desc = "Computes the most important constant all around the globe!")
+    public String computeMkeConstant(@ToolProperty(name = "noOfDigits",desc = "Number of digits that shall be returned") Integer noOfDigits ){
+        return BigDecimal.valueOf((long)(Math.random()*1000000L),noOfDigits).toString();
+    }
+}
+```
+
+The caller API can then be written as:
+```java
+import io.github.ollama4j.tools.annotations.OllamaToolService;
+
+@OllamaToolService(providers = BackendService.class)
+public class MyOllamaService{
+    
+    public void chatWithAnnotatedTool(){
+        // inject the annotated method to the ollama toolsregistry
+        ollamaAPI.registerAnnotatedTools();
+
+        OllamaChatRequest requestModel = builder
+                .withMessage(OllamaChatMessageRole.USER,
+                        "Compute the most important constant in the world using 5 digits")
+                .build();
+
+        OllamaChatResult chatResult = ollamaAPI.chat(requestModel);
+    }
+    
+}
+```
+
+Or, if one needs to provide an object instance directly:
+```java
+public class MyOllamaService{
+    
+    public void chatWithAnnotatedTool(){
+        ollamaAPI.registerAnnotatedTools(new BackendService());
+        OllamaChatRequest requestModel = builder
+                .withMessage(OllamaChatMessageRole.USER,
+                        "Compute the most important constant in the world using 5 digits")
+                .build();
+
+        OllamaChatResult chatResult = ollamaAPI.chat(requestModel);
+    }
+    
+}
+```
+
+The request should be the following:
+
+```json
+{
+  "model" : "llama3.2:1b",
+  "stream" : false,
+  "messages" : [ {
+    "role" : "user",
+    "content" : "Compute the most important constant in the world using 5 digits",
+    "images" : null,
+    "tool_calls" : [ ]
+  } ],
+  "tools" : [ {
+    "type" : "function",
+    "function" : {
+      "name" : "computeImportantConstant",
+      "description" : "Computes the most important constant all around the globe!",
+      "parameters" : {
+        "type" : "object",
+        "properties" : {
+          "noOfDigits" : {
+            "type" : "java.lang.Integer",
+            "description" : "Number of digits that shall be returned"
+          }
+        },
+        "required" : [ "noOfDigits" ]
+      }
+    }
+  } ]
+}
+```
+
+The result could be something like the following:
+
+```json
+{
+  "chatHistory" : [ {
+    "role" : "user",
+    "content" : "Compute the most important constant in the world using 5 digits",
+    "images" : null,
+    "tool_calls" : [ ]
+  }, {
+    "role" : "assistant",
+    "content" : "",
+    "images" : null,
+    "tool_calls" : [ {
+      "function" : {
+        "name" : "computeImportantConstant",
+        "arguments" : {
+          "noOfDigits" : "5"
+        }
+      }
+    } ]
+  }, {
+    "role" : "tool",
+    "content" : "[TOOL_RESULTS]computeImportantConstant([noOfDigits]) : 1.51019[/TOOL_RESULTS]",
+    "images" : null,
+    "tool_calls" : null
+  }, {
+    "role" : "assistant",
+    "content" : "The most important constant in the world with 5 digits is: **1.51019**",
+    "images" : null,
+    "tool_calls" : null
+  } ],
+  "responseModel" : {
+    "model" : "llama3.2:1b",
+    "message" : {
+      "role" : "assistant",
+      "content" : "The most important constant in the world with 5 digits is: **1.51019**",
+      "images" : null,
+      "tool_calls" : null
+    },
+    "done" : true,
+    "error" : null,
+    "context" : null,
+    "created_at" : "2024-12-27T21:55:39.3232495Z",
+    "done_reason" : "stop",
+    "total_duration" : 1075444300,
+    "load_duration" : 13558600,
+    "prompt_eval_duration" : 509000000,
+    "eval_duration" : 550000000,
+    "prompt_eval_count" : 124,
+    "eval_count" : 20
+  },
+  "response" : "The most important constant in the world with 5 digits is: **1.51019**",
+  "responseTime" : 1075444300,
+  "httpStatusCode" : 200
+}
+```
+
+### Potential Improvements
+
 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:
 
@@ -369,4 +639,4 @@ public String getCurrentFuelPrice(String location, String fuelType) {
 }
 ```
 
-Updating async/chat APIs with support for tool-based generation. 
+Updating async/chat APIs with support for tool-based generation. 

docs/docs/apis-model-management/create-model.md

@@ -1,12 +1,12 @@
 ---
-sidebar_position: 4
+sidebar_position: 5
 ---
 
 # Create Model
 
 This API lets you create a custom model on the Ollama server.
 
-### Create a model from an existing Modelfile in the Ollama server
+### Create a custom model from an existing model in the Ollama server
 
 ```java title="CreateModel.java"
 import io.github.ollama4j.OllamaAPI;
@@ -19,144 +19,220 @@ public class CreateModel {
 
         OllamaAPI ollamaAPI = new OllamaAPI(host);
 
-        ollamaAPI.createModelWithFilePath("mario", "/path/to/mario/modelfile/on/ollama-server");
-    }
-}
-```
-
-### Create a model by passing the contents of Modelfile
-
-```java title="CreateModel.java"
-public class CreateModel {
-
-    public static void main(String[] args) {
-
-        String host = "http://localhost:11434/";
-
-        OllamaAPI ollamaAPI = new OllamaAPI(host);
-
-        ollamaAPI.createModelWithModelFileContents("mario", "FROM llama2\nSYSTEM You are mario from Super Mario Bros.");
+        ollamaAPI.createModel(CustomModelRequest.builder().model("mario").from("llama3.2:latest").system("You are Mario from Super Mario Bros.").build());
     }
 }
 ```
 
 Once created, you can see it when you use [list models](./list-models) API.
 
-### Example of a `Modelfile`
+[Read more](https://github.com/ollama/ollama/blob/main/docs/api.md#create-a-model) about custom model creation and the parameters available for model creation.
 
-```
-FROM llama2
-# sets the temperature to 1 [higher is more creative, lower is more coherent]
-PARAMETER temperature 1
-# sets the context window size to 4096, this controls how many tokens the LLM can use as context to generate the next token
-PARAMETER num_ctx 4096
+[//]: # ()
+[//]: # (### Example of a `Modelfile`)
 
-# sets a custom system message to specify the behavior of the chat assistant
-SYSTEM You are Mario from super mario bros, acting as an assistant.
-```
+[//]: # ()
+[//]: # (```)
 
-### Format of the `Modelfile`
+[//]: # (FROM llama2)
 
-```modelfile
-# comment
-INSTRUCTION arguments
-```
+[//]: # (# sets the temperature to 1 [higher is more creative, lower is more coherent])
 
-| Instruction                         | Description                                                    |
-|-------------------------------------|----------------------------------------------------------------|
-| [`FROM`](#from-required) (required) | Defines the base model to use.                                 |
-| [`PARAMETER`](#parameter)           | Sets the parameters for how Ollama will run the model.         |
-| [`TEMPLATE`](#template)             | The full prompt template to be sent to the model.              |
-| [`SYSTEM`](#system)                 | Specifies the system message that will be set in the template. |
-| [`ADAPTER`](#adapter)               | Defines the (Q)LoRA adapters to apply to the model.            |
-| [`LICENSE`](#license)               | Specifies the legal license.                                   |
+[//]: # (PARAMETER temperature 1)
 
-#### PARAMETER
+[//]: # (# sets the context window size to 4096, this controls how many tokens the LLM can use as context to generate the next token)
 
-The `PARAMETER` instruction defines a parameter that can be set when the model is run.
+[//]: # (PARAMETER num_ctx 4096)
 
-| Parameter      | Description                                                                                                                                                                                                                                             | Value Type | Example Usage        |
-|----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------|----------------------|
-| mirostat       | Enable Mirostat sampling for controlling perplexity. (default: 0, 0 = disabled, 1 = Mirostat, 2 = Mirostat 2.0)                                                                                                                                         | int        | mirostat 0           |
-| mirostat_eta   | Influences how quickly the algorithm responds to feedback from the generated text. A lower learning rate will result in slower adjustments, while a higher learning rate will make the algorithm more responsive. (Default: 0.1)                        | float      | mirostat_eta 0.1     |
-| mirostat_tau   | Controls the balance between coherence and diversity of the output. A lower value will result in more focused and coherent text. (Default: 5.0)                                                                                                         | float      | mirostat_tau 5.0     |
-| num_ctx        | Sets the size of the context window used to generate the next token. (Default: 2048)                                                                                                                                                                    | int        | num_ctx 4096         |
-| num_gqa        | The number of GQA groups in the transformer layer. Required for some models, for example it is 8 for llama2:70b                                                                                                                                         | int        | num_gqa 1            |
-| num_gpu        | The number of layers to send to the GPU(s). On macOS it defaults to 1 to enable metal support, 0 to disable.                                                                                                                                            | int        | num_gpu 50           |
-| num_thread     | Sets the number of threads to use during computation. By default, Ollama will detect this for optimal performance. It is recommended to set this value to the number of physical CPU cores your system has (as opposed to the logical number of cores). | int        | num_thread 8         |
-| repeat_last_n  | Sets how far back for the model to look back to prevent repetition. (Default: 64, 0 = disabled, -1 = num_ctx)                                                                                                                                           | int        | repeat_last_n 64     |
-| repeat_penalty | Sets how strongly to penalize repetitions. A higher value (e.g., 1.5) will penalize repetitions more strongly, while a lower value (e.g., 0.9) will be more lenient. (Default: 1.1)                                                                     | float      | repeat_penalty 1.1   |
-| temperature    | The temperature of the model. Increasing the temperature will make the model answer more creatively. (Default: 0.8)                                                                                                                                     | float      | temperature 0.7      |
-| seed           | Sets the random number seed to use for generation. Setting this to a specific number will make the model generate the same text for the same prompt. (Default: 0)                                                                                       | int        | seed 42              |
-| stop           | Sets the stop sequences to use. When this pattern is encountered the LLM will stop generating text and return. Multiple stop patterns may be set by specifying multiple separate `stop` parameters in a modelfile.                                      | string     | stop "AI assistant:" |
-| tfs_z          | Tail free sampling is used to reduce the impact of less probable tokens from the output. A higher value (e.g., 2.0) will reduce the impact more, while a value of 1.0 disables this setting. (default: 1)                                               | float      | tfs_z 1              |
-| num_predict    | Maximum number of tokens to predict when generating text. (Default: 128, -1 = infinite generation, -2 = fill context)                                                                                                                                   | int        | num_predict 42       |
-| top_k          | Reduces the probability of generating nonsense. A higher value (e.g. 100) will give more diverse answers, while a lower value (e.g. 10) will be more conservative. (Default: 40)                                                                        | int        | top_k 40             |
-| top_p          | Works together with top-k. A higher value (e.g., 0.95) will lead to more diverse text, while a lower value (e.g., 0.5) will generate more focused and conservative text. (Default: 0.9)                                                                 | float      | top_p 0.9            |
+[//]: # ()
+[//]: # (# sets a custom system message to specify the behavior of the chat assistant)
 
-#### TEMPLATE
+[//]: # (SYSTEM You are Mario from super mario bros, acting as an assistant.)
 
-`TEMPLATE` of the full prompt template to be passed into the model. It may include (optionally) a system message and a
-user's prompt. This is used to create a full custom prompt, and syntax may be model specific. You can usually find the
-template for a given model in the readme for that model.
+[//]: # (```)
 
-#### Template Variables
+[//]: # ()
+[//]: # (### Format of the `Modelfile`)
 
-| Variable        | Description                                                                                                   |
-|-----------------|---------------------------------------------------------------------------------------------------------------|
-| `{{ .System }}` | The system message used to specify custom behavior, this must also be set in the Modelfile as an instruction. |
-| `{{ .Prompt }}` | The incoming prompt, this is not specified in the model file and will be set based on input.                  |
-| `{{ .First }}`  | A boolean value used to render specific template information for the first generation of a session.           |
+[//]: # ()
+[//]: # (```modelfile)
 
-```modelfile
-TEMPLATE """
-{{- if .First }}
-### System:
-{{ .System }}
-{{- end }}
+[//]: # (# comment)
 
-### User:
-{{ .Prompt }}
+[//]: # (INSTRUCTION arguments)
 
-### Response:
-"""
+[//]: # (```)
 
-SYSTEM """<system message>"""
-```
+[//]: # ()
+[//]: # (| Instruction                         | Description                                                    |)
 
-### SYSTEM
+[//]: # (|-------------------------------------|----------------------------------------------------------------|)
 
-The `SYSTEM` instruction specifies the system message to be used in the template, if applicable.
+[//]: # (| [`FROM`]&#40;#from-required&#41; &#40;required&#41; | Defines the base model to use.                                 |)
 
-```modelfile
-SYSTEM """<system message>"""
-```
+[//]: # (| [`PARAMETER`]&#40;#parameter&#41;           | Sets the parameters for how Ollama will run the model.         |)
 
-### ADAPTER
+[//]: # (| [`TEMPLATE`]&#40;#template&#41;             | The full prompt template to be sent to the model.              |)
 
-The `ADAPTER` instruction specifies the LoRA adapter to apply to the base model. The value of this instruction should be
-an absolute path or a path relative to the Modelfile and the file must be in a GGML file format. The adapter should be
-tuned from the base model otherwise the behaviour is undefined.
+[//]: # (| [`SYSTEM`]&#40;#system&#41;                 | Specifies the system message that will be set in the template. |)
 
-```modelfile
-ADAPTER ./ollama-lora.bin
-```
+[//]: # (| [`ADAPTER`]&#40;#adapter&#41;               | Defines the &#40;Q&#41;LoRA adapters to apply to the model.            |)
 
-### LICENSE
+[//]: # (| [`LICENSE`]&#40;#license&#41;               | Specifies the legal license.                                   |)
 
-The `LICENSE` instruction allows you to specify the legal license under which the model used with this Modelfile is
-shared or distributed.
+[//]: # ()
+[//]: # (#### PARAMETER)
 
-```modelfile
-LICENSE """
-<license text>
-"""
-```
+[//]: # ()
+[//]: # (The `PARAMETER` instruction defines a parameter that can be set when the model is run.)
 
-## Notes
+[//]: # ()
+[//]: # (| Parameter      | Description                                                                                                                                                                                                                                             | Value Type | Example Usage        |)
 
-- the **`Modelfile` is not case sensitive**. In the examples, uppercase instructions are used to make it easier to
-  distinguish it from arguments.
-- Instructions can be in any order. In the examples, the `FROM` instruction is first to keep it easily readable.
+[//]: # (|----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------|----------------------|)
 
-Read more about Modelfile: https://github.com/jmorganca/ollama/blob/main/docs/modelfile.md
+[//]: # (| mirostat       | Enable Mirostat sampling for controlling perplexity. &#40;default: 0, 0 = disabled, 1 = Mirostat, 2 = Mirostat 2.0&#41;                                                                                                                                         | int        | mirostat 0           |)
+
+[//]: # (| mirostat_eta   | Influences how quickly the algorithm responds to feedback from the generated text. A lower learning rate will result in slower adjustments, while a higher learning rate will make the algorithm more responsive. &#40;Default: 0.1&#41;                        | float      | mirostat_eta 0.1     |)
+
+[//]: # (| mirostat_tau   | Controls the balance between coherence and diversity of the output. A lower value will result in more focused and coherent text. &#40;Default: 5.0&#41;                                                                                                         | float      | mirostat_tau 5.0     |)
+
+[//]: # (| num_ctx        | Sets the size of the context window used to generate the next token. &#40;Default: 2048&#41;                                                                                                                                                                    | int        | num_ctx 4096         |)
+
+[//]: # (| num_gqa        | The number of GQA groups in the transformer layer. Required for some models, for example it is 8 for llama2:70b                                                                                                                                         | int        | num_gqa 1            |)
+
+[//]: # (| num_gpu        | The number of layers to send to the GPU&#40;s&#41;. On macOS it defaults to 1 to enable metal support, 0 to disable.                                                                                                                                            | int        | num_gpu 50           |)
+
+[//]: # (| num_thread     | Sets the number of threads to use during computation. By default, Ollama will detect this for optimal performance. It is recommended to set this value to the number of physical CPU cores your system has &#40;as opposed to the logical number of cores&#41;. | int        | num_thread 8         |)
+
+[//]: # (| repeat_last_n  | Sets how far back for the model to look back to prevent repetition. &#40;Default: 64, 0 = disabled, -1 = num_ctx&#41;                                                                                                                                           | int        | repeat_last_n 64     |)
+
+[//]: # (| repeat_penalty | Sets how strongly to penalize repetitions. A higher value &#40;e.g., 1.5&#41; will penalize repetitions more strongly, while a lower value &#40;e.g., 0.9&#41; will be more lenient. &#40;Default: 1.1&#41;                                                                     | float      | repeat_penalty 1.1   |)
+
+[//]: # (| temperature    | The temperature of the model. Increasing the temperature will make the model answer more creatively. &#40;Default: 0.8&#41;                                                                                                                                     | float      | temperature 0.7      |)
+
+[//]: # (| seed           | Sets the random number seed to use for generation. Setting this to a specific number will make the model generate the same text for the same prompt. &#40;Default: 0&#41;                                                                                       | int        | seed 42              |)
+
+[//]: # (| stop           | Sets the stop sequences to use. When this pattern is encountered the LLM will stop generating text and return. Multiple stop patterns may be set by specifying multiple separate `stop` parameters in a modelfile.                                      | string     | stop "AI assistant:" |)
+
+[//]: # (| tfs_z          | Tail free sampling is used to reduce the impact of less probable tokens from the output. A higher value &#40;e.g., 2.0&#41; will reduce the impact more, while a value of 1.0 disables this setting. &#40;default: 1&#41;                                               | float      | tfs_z 1              |)
+
+[//]: # (| num_predict    | Maximum number of tokens to predict when generating text. &#40;Default: 128, -1 = infinite generation, -2 = fill context&#41;                                                                                                                                   | int        | num_predict 42       |)
+
+[//]: # (| top_k          | Reduces the probability of generating nonsense. A higher value &#40;e.g. 100&#41; will give more diverse answers, while a lower value &#40;e.g. 10&#41; will be more conservative. &#40;Default: 40&#41;                                                                        | int        | top_k 40             |)
+
+[//]: # (| top_p          | Works together with top-k. A higher value &#40;e.g., 0.95&#41; will lead to more diverse text, while a lower value &#40;e.g., 0.5&#41; will generate more focused and conservative text. &#40;Default: 0.9&#41;                                                                 | float      | top_p 0.9            |)
+
+[//]: # ()
+[//]: # (#### TEMPLATE)
+
+[//]: # ()
+[//]: # (`TEMPLATE` of the full prompt template to be passed into the model. It may include &#40;optionally&#41; a system message and a)
+
+[//]: # (user's prompt. This is used to create a full custom prompt, and syntax may be model specific. You can usually find the)
+
+[//]: # (template for a given model in the readme for that model.)
+
+[//]: # ()
+[//]: # (#### Template Variables)
+
+[//]: # ()
+[//]: # (| Variable        | Description                                                                                                   |)
+
+[//]: # (|-----------------|---------------------------------------------------------------------------------------------------------------|)
+
+[//]: # (| `{{ .System }}` | The system message used to specify custom behavior, this must also be set in the Modelfile as an instruction. |)
+
+[//]: # (| `{{ .Prompt }}` | The incoming prompt, this is not specified in the model file and will be set based on input.                  |)
+
+[//]: # (| `{{ .First }}`  | A boolean value used to render specific template information for the first generation of a session.           |)
+
+[//]: # ()
+[//]: # (```modelfile)
+
+[//]: # (TEMPLATE """)
+
+[//]: # ({{- if .First }})
+
+[//]: # (### System:)
+
+[//]: # ({{ .System }})
+
+[//]: # ({{- end }})
+
+[//]: # ()
+[//]: # (### User:)
+
+[//]: # ({{ .Prompt }})
+
+[//]: # ()
+[//]: # (### Response:)
+
+[//]: # (""")
+
+[//]: # ()
+[//]: # (SYSTEM """<system message>""")
+
+[//]: # (```)
+
+[//]: # ()
+[//]: # (### SYSTEM)
+
+[//]: # ()
+[//]: # (The `SYSTEM` instruction specifies the system message to be used in the template, if applicable.)
+
+[//]: # ()
+[//]: # (```modelfile)
+
+[//]: # (SYSTEM """<system message>""")
+
+[//]: # (```)
+
+[//]: # ()
+[//]: # (### ADAPTER)
+
+[//]: # ()
+[//]: # (The `ADAPTER` instruction specifies the LoRA adapter to apply to the base model. The value of this instruction should be)
+
+[//]: # (an absolute path or a path relative to the Modelfile and the file must be in a GGML file format. The adapter should be)
+
+[//]: # (tuned from the base model otherwise the behaviour is undefined.)
+
+[//]: # ()
+[//]: # (```modelfile)
+
+[//]: # (ADAPTER ./ollama-lora.bin)
+
+[//]: # (```)
+
+[//]: # ()
+[//]: # (### LICENSE)
+
+[//]: # ()
+[//]: # (The `LICENSE` instruction allows you to specify the legal license under which the model used with this Modelfile is)
+
+[//]: # (shared or distributed.)
+
+[//]: # ()
+[//]: # (```modelfile)
+
+[//]: # (LICENSE """)
+
+[//]: # (<license text>)
+
+[//]: # (""")
+
+[//]: # (```)
+
+[//]: # ()
+[//]: # (## Notes)
+
+[//]: # ()
+[//]: # (- the **`Modelfile` is not case sensitive**. In the examples, uppercase instructions are used to make it easier to)
+
+[//]: # (  distinguish it from arguments.)
+
+[//]: # (- Instructions can be in any order. In the examples, the `FROM` instruction is first to keep it easily readable.)
+
+[//]: # ()
+[//]: # (Read more about Modelfile: https://github.com/jmorganca/ollama/blob/main/docs/modelfile.md)

docs/docs/apis-model-management/delete-model.md

@@ -1,5 +1,5 @@
 ---
-sidebar_position: 5
+sidebar_position: 6
 ---
 
 # Delete Model

docs/docs/apis-model-management/get-model-details.md

@@ -1,5 +1,5 @@
 ---
-sidebar_position: 3
+sidebar_position: 4
 ---
 
 # Get Model Details

docs/docs/apis-model-management/list-library-models.md

@@ -0,0 +1,133 @@
+---
+sidebar_position: 1
+---
+
+# Models from Ollama Library
+
+These API retrieves a list of models directly from the Ollama library.
+
+### List Models from Ollama Library
+
+This API fetches available models from the Ollama library page, including details such as the model's name, pull count,
+popular tags, tag count, and the last update time.
+
+```java title="ListLibraryModels.java"
+import io.github.ollama4j.OllamaAPI;
+import io.github.ollama4j.models.response.LibraryModel;
+
+import java.util.List;
+
+public class Main {
+
+    public static void main(String[] args) {
+
+        String host = "http://localhost:11434/";
+
+        OllamaAPI ollamaAPI = new OllamaAPI(host);
+
+        List<LibraryModel> libraryModels = ollamaAPI.listModelsFromLibrary();
+
+        System.out.println(libraryModels);
+    }
+}
+```
+
+The following is the sample output:
+
+```
+[
+    LibraryModel(name=llama3.2-vision, description=Llama 3.2 Vision is a collection of instruction-tuned image reasoning generative models in 11B and 90B sizes., pullCount=21.1K, totalTags=9, popularTags=[vision, 11b, 90b], lastUpdated=yesterday), 
+    LibraryModel(name=llama3.2, description=Meta's Llama 3.2 goes small with 1B and 3B models., pullCount=2.4M, totalTags=63, popularTags=[tools, 1b, 3b], lastUpdated=6 weeks ago)
+]
+```
+
+### Get Tags of a Library Model
+
+This API Fetches the tags associated with a specific model from Ollama library.
+
+```java title="GetLibraryModelTags.java"
+import io.github.ollama4j.OllamaAPI;
+import io.github.ollama4j.models.response.LibraryModel;
+import io.github.ollama4j.models.response.LibraryModelDetail;
+
+public class Main {
+
+    public static void main(String[] args) {
+
+        String host = "http://localhost:11434/";
+
+        OllamaAPI ollamaAPI = new OllamaAPI(host);
+
+        List<LibraryModel> libraryModels = ollamaAPI.listModelsFromLibrary();
+
+        LibraryModelDetail libraryModelDetail = ollamaAPI.getLibraryModelDetails(libraryModels.get(0));
+
+        System.out.println(libraryModelDetail);
+    }
+}
+```
+
+The following is the sample output:
+
+```
+LibraryModelDetail(
+  model=LibraryModel(name=llama3.2-vision, description=Llama 3.2 Vision is a collection of instruction-tuned image reasoning generative models in 11B and 90B sizes., pullCount=21.1K, totalTags=9, popularTags=[vision, 11b, 90b], lastUpdated=yesterday), 
+  tags=[
+        LibraryModelTag(name=llama3.2-vision, tag=latest, size=7.9GB, lastUpdated=yesterday), 
+        LibraryModelTag(name=llama3.2-vision, tag=11b, size=7.9GB, lastUpdated=yesterday), 
+        LibraryModelTag(name=llama3.2-vision, tag=90b, size=55GB, lastUpdated=yesterday)
+    ]
+)
+```
+
+### Find a model from Ollama library
+
+This API finds a specific model using model `name` and `tag` from Ollama library.
+
+```java title="FindLibraryModel.java"
+import io.github.ollama4j.OllamaAPI;
+import io.github.ollama4j.models.response.LibraryModelTag;
+
+public class Main {
+
+    public static void main(String[] args) {
+
+        String host = "http://localhost:11434/";
+
+        OllamaAPI ollamaAPI = new OllamaAPI(host);
+
+        LibraryModelTag libraryModelTag = ollamaAPI.findModelTagFromLibrary("qwen2.5", "7b");
+
+        System.out.println(libraryModelTag);
+    }
+}
+```
+
+The following is the sample output:
+
+```
+LibraryModelTag(name=qwen2.5, tag=7b, size=4.7GB, lastUpdated=7 weeks ago)
+```
+
+### Pull model using `LibraryModelTag`
+
+You can use `LibraryModelTag` to pull models into Ollama server.
+
+```java title="PullLibraryModelTags.java"
+import io.github.ollama4j.OllamaAPI;
+import io.github.ollama4j.models.response.LibraryModelTag;
+
+public class Main {
+
+    public static void main(String[] args) {
+
+        String host = "http://localhost:11434/";
+
+        OllamaAPI ollamaAPI = new OllamaAPI(host);
+
+        LibraryModelTag libraryModelTag = ollamaAPI.findModelTagFromLibrary("qwen2.5", "7b");
+
+        ollamaAPI.pullModel(libraryModelTag);
+    }
+}
+```

docs/docs/apis-model-management/list-models.md

@@ -1,10 +1,10 @@
 ---
-sidebar_position: 1
+sidebar_position: 2
 ---
 
-# List Models
+# List Local Models
 
-This API lets you list available models on the Ollama server.
+This API lets you list downloaded/available models on the Ollama server.
 
 ```java title="ListModels.java"
 import io.github.ollama4j.OllamaAPI;

docs/docs/apis-model-management/pull-model.md

@@ -1,5 +1,5 @@
 ---
-sidebar_position: 2
+sidebar_position: 3
 ---
 
 # Pull Model
@@ -23,4 +23,12 @@ public class Main {
 }
 ```
 
-Once downloaded, you can see them when you use [list models](./list-models) API.
+Once downloaded, you can see them when you use [list models](./list-models) API.
+
+:::info
+
+You can even pull models using Ollama model library APIs. This looks up the models directly on the Ollama model library page. Refer
+to [this](./list-library-models#pull-model-using-librarymodeltag).
+
+:::
+

pom.xml

@@ -140,6 +140,11 @@
             <version>${lombok.version}</version>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>org.jsoup</groupId>
+            <artifactId>jsoup</artifactId>
+            <version>1.18.1</version>
+        </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>

src/main/java/io/github/ollama4j/OllamaAPI.java

@@ -11,17 +11,22 @@ import io.github.ollama4j.models.embeddings.OllamaEmbeddingsRequestModel;
 import io.github.ollama4j.models.embeddings.OllamaEmbedResponseModel;
 import io.github.ollama4j.models.generate.OllamaGenerateRequest;
 import io.github.ollama4j.models.generate.OllamaStreamHandler;
+import io.github.ollama4j.models.generate.OllamaTokenHandler;
 import io.github.ollama4j.models.ps.ModelsProcessResponse;
 import io.github.ollama4j.models.request.*;
 import io.github.ollama4j.models.response.*;
 import io.github.ollama4j.tools.*;
+import io.github.ollama4j.tools.annotations.OllamaToolService;
+import io.github.ollama4j.tools.annotations.ToolProperty;
+import io.github.ollama4j.tools.annotations.ToolSpec;
 import io.github.ollama4j.utils.Options;
 import io.github.ollama4j.utils.Utils;
 import lombok.Setter;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.io.*;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.net.http.HttpClient;
@@ -32,6 +37,14 @@ import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.time.Duration;
 import java.util.*;
+import java.util.stream.Collectors;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.jsoup.select.Elements;
 
 /**
  * The base Ollama API class.
@@ -53,6 +66,10 @@ public class OllamaAPI {
      */
     @Setter
     private boolean verbose = true;
+
+    @Setter
+    private int maxChatToolCallRetries = 3;
+
     private BasicAuth basicAuth;
 
     private final ToolRegistry toolRegistry = new ToolRegistry();
@@ -164,6 +181,130 @@ public class OllamaAPI {
         }
     }
 
+    /**
+     * Retrieves a list of models from the Ollama library. This method fetches the available models directly from Ollama
+     * library page, including model details such as the name, pull count, popular tags, tag count, and the time when model was updated.
+     *
+     * @return A list of {@link LibraryModel} objects representing the models available in the Ollama library.
+     * @throws OllamaBaseException  If the HTTP request fails or the response is not successful (non-200 status code).
+     * @throws IOException          If an I/O error occurs during the HTTP request or response processing.
+     * @throws InterruptedException If the thread executing the request is interrupted.
+     * @throws URISyntaxException   If there is an error creating the URI for the HTTP request.
+     */
+    public List<LibraryModel> listModelsFromLibrary() throws OllamaBaseException, IOException, InterruptedException, URISyntaxException {
+        String url = "https://ollama.com/library";
+        HttpClient httpClient = HttpClient.newHttpClient();
+        HttpRequest httpRequest = getRequestBuilderDefault(new URI(url)).header("Accept", "application/json").header("Content-type", "application/json").GET().build();
+        HttpResponse<String> response = httpClient.send(httpRequest, HttpResponse.BodyHandlers.ofString());
+        int statusCode = response.statusCode();
+        String responseString = response.body();
+        List<LibraryModel> models = new ArrayList<>();
+        if (statusCode == 200) {
+            Document doc = Jsoup.parse(responseString);
+            Elements modelSections = doc.selectXpath("//*[@id='repo']/ul/li/a");
+            for (Element e : modelSections) {
+                LibraryModel model = new LibraryModel();
+                Elements names = e.select("div > h2 > div > span");
+                Elements desc = e.select("div > p");
+                Elements pullCounts = e.select("div:nth-of-type(2) > p > span:first-of-type > span:first-of-type");
+                Elements popularTags = e.select("div > div > span");
+                Elements totalTags = e.select("div:nth-of-type(2) > p > span:nth-of-type(2) > span:first-of-type");
+                Elements lastUpdatedTime = e.select("div:nth-of-type(2) > p > span:nth-of-type(3) > span:nth-of-type(2)");
+
+                if (names.first() == null || names.isEmpty()) {
+                    // if name cannot be extracted, skip.
+                    continue;
+                }
+                Optional.ofNullable(names.first()).map(Element::text).ifPresent(model::setName);
+                model.setDescription(Optional.ofNullable(desc.first()).map(Element::text).orElse(""));
+                model.setPopularTags(Optional.of(popularTags).map(tags -> tags.stream().map(Element::text).collect(Collectors.toList())).orElse(new ArrayList<>()));
+                model.setPullCount(Optional.ofNullable(pullCounts.first()).map(Element::text).orElse(""));
+                model.setTotalTags(Optional.ofNullable(totalTags.first()).map(Element::text).map(Integer::parseInt).orElse(0));
+                model.setLastUpdated(Optional.ofNullable(lastUpdatedTime.first()).map(Element::text).orElse(""));
+
+                models.add(model);
+            }
+            return models;
+        } else {
+            throw new OllamaBaseException(statusCode + " - " + responseString);
+        }
+    }
+
+    /**
+     * Fetches the tags associated with a specific model from Ollama library.
+     * This method fetches the available model tags directly from Ollama library model page, including model tag name, size and time when model was last updated
+     * into a list of {@link LibraryModelTag} objects.
+     *
+     * @param libraryModel the {@link LibraryModel} object which contains the name of the library model
+     *                     for which the tags need to be fetched.
+     * @return a list of {@link LibraryModelTag} objects containing the extracted tags and their associated metadata.
+     * @throws OllamaBaseException  if the HTTP response status code indicates an error (i.e., not 200 OK),
+     *                              or if there is any other issue during the request or response processing.
+     * @throws IOException          if an input/output exception occurs during the HTTP request or response handling.
+     * @throws InterruptedException if the thread is interrupted while waiting for the HTTP response.
+     * @throws URISyntaxException   if the URI format is incorrect or invalid.
+     */
+    public LibraryModelDetail getLibraryModelDetails(LibraryModel libraryModel) throws OllamaBaseException, IOException, InterruptedException, URISyntaxException {
+        String url = String.format("https://ollama.com/library/%s/tags", libraryModel.getName());
+        HttpClient httpClient = HttpClient.newHttpClient();
+        HttpRequest httpRequest = getRequestBuilderDefault(new URI(url)).header("Accept", "application/json").header("Content-type", "application/json").GET().build();
+        HttpResponse<String> response = httpClient.send(httpRequest, HttpResponse.BodyHandlers.ofString());
+        int statusCode = response.statusCode();
+        String responseString = response.body();
+
+        List<LibraryModelTag> libraryModelTags = new ArrayList<>();
+        if (statusCode == 200) {
+            Document doc = Jsoup.parse(responseString);
+            Elements tagSections = doc.select("html > body > main > div > section > div > div > div:nth-child(n+2) > div");
+            for (Element e : tagSections) {
+                Elements tags = e.select("div > a > div");
+                Elements tagsMetas = e.select("div > span");
+
+                LibraryModelTag libraryModelTag = new LibraryModelTag();
+
+                if (tags.first() == null || tags.isEmpty()) {
+                    // if tag cannot be extracted, skip.
+                    continue;
+                }
+                libraryModelTag.setName(libraryModel.getName());
+                Optional.ofNullable(tags.first()).map(Element::text).ifPresent(libraryModelTag::setTag);
+                libraryModelTag.setSize(Optional.ofNullable(tagsMetas.first()).map(element -> element.text().split("•")).filter(parts -> parts.length > 1).map(parts -> parts[1].trim()).orElse(""));
+                libraryModelTag.setLastUpdated(Optional.ofNullable(tagsMetas.first()).map(element -> element.text().split("•")).filter(parts -> parts.length > 1).map(parts -> parts[2].trim()).orElse(""));
+                libraryModelTags.add(libraryModelTag);
+            }
+            LibraryModelDetail libraryModelDetail = new LibraryModelDetail();
+            libraryModelDetail.setModel(libraryModel);
+            libraryModelDetail.setTags(libraryModelTags);
+            return libraryModelDetail;
+        } else {
+            throw new OllamaBaseException(statusCode + " - " + responseString);
+        }
+    }
+
+    /**
+     * Finds a specific model using model name and tag from Ollama library.
+     * <p>
+     * This method retrieves the model from the Ollama library by its name, then fetches its tags.
+     * It searches through the tags of the model to find one that matches the specified tag name.
+     * If the model or the tag is not found, it throws a {@link NoSuchElementException}.
+     *
+     * @param modelName The name of the model to search for in the library.
+     * @param tag       The tag name to search for within the specified model.
+     * @return The {@link LibraryModelTag} associated with the specified model and tag.
+     * @throws OllamaBaseException    If there is a problem with the Ollama library operations.
+     * @throws IOException            If an I/O error occurs during the operation.
+     * @throws URISyntaxException     If there is an error with the URI syntax.
+     * @throws InterruptedException   If the operation is interrupted.
+     * @throws NoSuchElementException If the model or the tag is not found.
+     */
+    public LibraryModelTag findModelTagFromLibrary(String modelName, String tag) throws OllamaBaseException, IOException, URISyntaxException, InterruptedException {
+        List<LibraryModel> libraryModels = this.listModelsFromLibrary();
+        LibraryModel libraryModel = libraryModels.stream().filter(model -> model.getName().equals(modelName)).findFirst().orElseThrow(() -> new NoSuchElementException(String.format("Model by name '%s' not found", modelName)));
+        LibraryModelDetail libraryModelDetail = this.getLibraryModelDetails(libraryModel);
+        LibraryModelTag libraryModelTag = libraryModelDetail.getTags().stream().filter(tagName -> tagName.getTag().equals(tag)).findFirst().orElseThrow(() -> new NoSuchElementException(String.format("Tag '%s' for model '%s' not found", tag, modelName)));
+        return libraryModelTag;
+    }
+
     /**
      * Pull a model on the Ollama server from the list of <a
      * href="https://ollama.ai/library">available models</a>.
@@ -197,6 +338,23 @@ public class OllamaAPI {
         }
     }
 
+    /**
+     * Pulls a model using the specified Ollama library model tag.
+     * The model is identified by a name and a tag, which are combined into a single identifier
+     * in the format "name:tag" to pull the corresponding model.
+     *
+     * @param libraryModelTag the {@link LibraryModelTag} object containing the name and tag
+     *                        of the model to be pulled.
+     * @throws OllamaBaseException  if the response indicates an error status
+     * @throws IOException          if an I/O error occurs during the HTTP request
+     * @throws InterruptedException if the operation is interrupted
+     * @throws URISyntaxException   if the URI for the request is malformed
+     */
+    public void pullModel(LibraryModelTag libraryModelTag) throws OllamaBaseException, IOException, URISyntaxException, InterruptedException {
+        String tagToPull = String.format("%s:%s", libraryModelTag.getName(), libraryModelTag.getTag());
+        pullModel(tagToPull);
+    }
+
     /**
      * Gets model details from the Ollama server.
      *
@@ -233,6 +391,7 @@ public class OllamaAPI {
      * @throws InterruptedException if the operation is interrupted
      * @throws URISyntaxException   if the URI for the request is malformed
      */
+    @Deprecated
     public void createModelWithFilePath(String modelName, String modelFilePath) throws IOException, InterruptedException, OllamaBaseException, URISyntaxException {
         String url = this.host + "/api/create";
         String jsonData = new CustomModelFilePathRequest(modelName, modelFilePath).toString();
@@ -265,6 +424,7 @@ public class OllamaAPI {
      * @throws InterruptedException if the operation is interrupted
      * @throws URISyntaxException   if the URI for the request is malformed
      */
+    @Deprecated
     public void createModelWithModelFileContents(String modelName, String modelFileContents) throws IOException, InterruptedException, OllamaBaseException, URISyntaxException {
         String url = this.host + "/api/create";
         String jsonData = new CustomModelFileContentsRequest(modelName, modelFileContents).toString();
@@ -284,6 +444,35 @@ public class OllamaAPI {
         }
     }
 
+    /**
+     * Create a custom model. Read more about custom model creation <a
+     * href="https://github.com/ollama/ollama/blob/main/docs/api.md#create-a-model">here</a>.
+     *
+     * @param customModelRequest custom model spec
+     * @throws OllamaBaseException  if the response indicates an error status
+     * @throws IOException          if an I/O error occurs during the HTTP request
+     * @throws InterruptedException if the operation is interrupted
+     * @throws URISyntaxException   if the URI for the request is malformed
+     */
+    public void createModel(CustomModelRequest customModelRequest) throws IOException, InterruptedException, OllamaBaseException, URISyntaxException {
+        String url = this.host + "/api/create";
+        String jsonData = customModelRequest.toString();
+        HttpRequest request = getRequestBuilderDefault(new URI(url)).header("Accept", "application/json").header("Content-Type", "application/json").POST(HttpRequest.BodyPublishers.ofString(jsonData, StandardCharsets.UTF_8)).build();
+        HttpClient client = HttpClient.newHttpClient();
+        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+        int statusCode = response.statusCode();
+        String responseString = response.body();
+        if (statusCode != 200) {
+            throw new OllamaBaseException(statusCode + " - " + responseString);
+        }
+        if (responseString.contains("error")) {
+            throw new OllamaBaseException(responseString);
+        }
+        if (verbose) {
+            logger.info(responseString);
+        }
+    }
+
     /**
      * Delete a model from Ollama server.
      *
@@ -452,6 +641,15 @@ public class OllamaAPI {
         OllamaToolsResult toolResult = new OllamaToolsResult();
         Map<ToolFunctionCallSpec, Object> toolResults = new HashMap<>();
 
+        if (!prompt.startsWith("[AVAILABLE_TOOLS]")) {
+            final Tools.PromptBuilder promptBuilder = new Tools.PromptBuilder();
+            for (Tools.ToolSpecification spec : toolRegistry.getRegisteredSpecs()) {
+                promptBuilder.withToolSpecification(spec);
+            }
+            promptBuilder.withPrompt(prompt);
+            prompt = promptBuilder.build();
+        }
+
         OllamaResult result = generate(model, prompt, raw, options, null);
         toolResult.setModelResult(result);
 
@@ -619,19 +817,159 @@ public class OllamaAPI {
      * @throws InterruptedException if the operation is interrupted
      */
     public OllamaChatResult chat(OllamaChatRequest request, OllamaStreamHandler streamHandler) throws OllamaBaseException, IOException, InterruptedException {
+        return chatStreaming(request, new OllamaChatStreamObserver(streamHandler));
+    }
+
+    /**
+     * Ask a question to a model using an {@link OllamaChatRequest}. This can be constructed using an {@link OllamaChatRequestBuilder}.
+     * <p>
+     * Hint: the OllamaChatRequestModel#getStream() property is not implemented.
+     *
+     * @param request      request object to be sent to the server
+     * @param tokenHandler callback handler to handle the last token from stream (caution: all previous messages from stream will be concatenated)
+     * @return {@link OllamaChatResult}
+     * @throws OllamaBaseException  any response code than 200 has been returned
+     * @throws IOException          in case the responseStream can not be read
+     * @throws InterruptedException in case the server is not reachable or network issues happen
+     * @throws OllamaBaseException  if the response indicates an error status
+     * @throws IOException          if an I/O error occurs during the HTTP request
+     * @throws InterruptedException if the operation is interrupted
+     */
+    public OllamaChatResult chatStreaming(OllamaChatRequest request, OllamaTokenHandler tokenHandler) throws OllamaBaseException, IOException, InterruptedException {
         OllamaChatEndpointCaller requestCaller = new OllamaChatEndpointCaller(host, basicAuth, requestTimeoutSeconds, verbose);
-        OllamaResult result;
-        if (streamHandler != null) {
+        OllamaChatResult result;
+
+        // add all registered tools to Request
+        request.setTools(toolRegistry.getRegisteredSpecs().stream().map(Tools.ToolSpecification::getToolPrompt).collect(Collectors.toList()));
+
+        if (tokenHandler != null) {
             request.setStream(true);
-            result = requestCaller.call(request, streamHandler);
+            result = requestCaller.call(request, tokenHandler);
         } else {
             result = requestCaller.callSync(request);
         }
-        return new OllamaChatResult(result.getResponse(), result.getResponseTime(), result.getHttpStatusCode(), request.getMessages());
+
+        // check if toolCallIsWanted
+        List<OllamaChatToolCalls> toolCalls = result.getResponseModel().getMessage().getToolCalls();
+        int toolCallTries = 0;
+        while (toolCalls != null && !toolCalls.isEmpty() && toolCallTries < maxChatToolCallRetries) {
+            for (OllamaChatToolCalls toolCall : toolCalls) {
+                String toolName = toolCall.getFunction().getName();
+                ToolFunction toolFunction = toolRegistry.getToolFunction(toolName);
+                Map<String, Object> arguments = toolCall.getFunction().getArguments();
+                Object res = toolFunction.apply(arguments);
+                request.getMessages().add(new OllamaChatMessage(OllamaChatMessageRole.TOOL, "[TOOL_RESULTS]" + toolName + "(" + arguments.keySet() + ") : " + res + "[/TOOL_RESULTS]"));
+            }
+
+            if (tokenHandler != null) {
+                result = requestCaller.call(request, tokenHandler);
+            } else {
+                result = requestCaller.callSync(request);
+            }
+            toolCalls = result.getResponseModel().getMessage().getToolCalls();
+            toolCallTries++;
+        }
+
+        return result;
     }
 
+    /**
+     * Registers a single tool in the tool registry using the provided tool specification.
+     *
+     * @param toolSpecification the specification of the tool to register. It contains the
+     *                          tool's function name and other relevant information.
+     */
     public void registerTool(Tools.ToolSpecification toolSpecification) {
-        toolRegistry.addFunction(toolSpecification.getFunctionName(), toolSpecification.getToolDefinition());
+        toolRegistry.addTool(toolSpecification.getFunctionName(), toolSpecification);
+    }
+
+    /**
+     * Registers multiple tools in the tool registry using a list of tool specifications.
+     * Iterates over the list and adds each tool specification to the registry.
+     *
+     * @param toolSpecifications a list of tool specifications to register. Each specification
+     *                           contains information about a tool, such as its function name.
+     */
+    public void registerTools(List<Tools.ToolSpecification> toolSpecifications) {
+        for (Tools.ToolSpecification toolSpecification : toolSpecifications) {
+            toolRegistry.addTool(toolSpecification.getFunctionName(), toolSpecification);
+        }
+    }
+
+    /**
+     * Registers tools based on the annotations found on the methods of the caller's class and its providers.
+     * This method scans the caller's class for the {@link OllamaToolService} annotation and recursively registers
+     * annotated tools from all the providers specified in the annotation.
+     *
+     * @throws IllegalStateException if the caller's class is not annotated with {@link OllamaToolService}.
+     * @throws RuntimeException      if any reflection-based instantiation or invocation fails.
+     */
+    public void registerAnnotatedTools() {
+        try {
+            Class<?> callerClass = null;
+            try {
+                callerClass = Class.forName(Thread.currentThread().getStackTrace()[2].getClassName());
+            } catch (ClassNotFoundException e) {
+                throw new RuntimeException(e);
+            }
+
+            OllamaToolService ollamaToolServiceAnnotation = callerClass.getDeclaredAnnotation(OllamaToolService.class);
+            if (ollamaToolServiceAnnotation == null) {
+                throw new IllegalStateException(callerClass + " is not annotated as " + OllamaToolService.class);
+            }
+
+            Class<?>[] providers = ollamaToolServiceAnnotation.providers();
+            for (Class<?> provider : providers) {
+                registerAnnotatedTools(provider.getDeclaredConstructor().newInstance());
+            }
+        } catch (InstantiationException | NoSuchMethodException | IllegalAccessException |
+                 InvocationTargetException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Registers tools based on the annotations found on the methods of the provided object.
+     * This method scans the methods of the given object and registers tools using the {@link ToolSpec} annotation
+     * and associated {@link ToolProperty} annotations. It constructs tool specifications and stores them in a tool registry.
+     *
+     * @param object the object whose methods are to be inspected for annotated tools.
+     * @throws RuntimeException if any reflection-based instantiation or invocation fails.
+     */
+    public void registerAnnotatedTools(Object object) {
+        Class<?> objectClass = object.getClass();
+        Method[] methods = objectClass.getMethods();
+        for (Method m : methods) {
+            ToolSpec toolSpec = m.getDeclaredAnnotation(ToolSpec.class);
+            if (toolSpec == null) {
+                continue;
+            }
+            String operationName = !toolSpec.name().isBlank() ? toolSpec.name() : m.getName();
+            String operationDesc = !toolSpec.desc().isBlank() ? toolSpec.desc() : operationName;
+
+            final Tools.PropsBuilder propsBuilder = new Tools.PropsBuilder();
+            LinkedHashMap<String, String> methodParams = new LinkedHashMap<>();
+            for (Parameter parameter : m.getParameters()) {
+                final ToolProperty toolPropertyAnn = parameter.getDeclaredAnnotation(ToolProperty.class);
+                String propType = parameter.getType().getTypeName();
+                if (toolPropertyAnn == null) {
+                    methodParams.put(parameter.getName(), null);
+                    continue;
+                }
+                String propName = !toolPropertyAnn.name().isBlank() ? toolPropertyAnn.name() : parameter.getName();
+                methodParams.put(propName, propType);
+                propsBuilder.withProperty(propName, Tools.PromptFuncDefinition.Property.builder().type(propType).description(toolPropertyAnn.desc()).required(toolPropertyAnn.required()).build());
+            }
+            final Map<String, Tools.PromptFuncDefinition.Property> params = propsBuilder.build();
+            List<String> reqProps = params.entrySet().stream().filter(e -> e.getValue().isRequired()).map(Map.Entry::getKey).collect(Collectors.toList());
+
+            Tools.ToolSpecification toolSpecification = Tools.ToolSpecification.builder().functionName(operationName).functionDescription(operationDesc).toolPrompt(Tools.PromptFuncDefinition.builder().type("function").function(Tools.PromptFuncDefinition.PromptFuncSpec.builder().name(operationName).description(operationDesc).parameters(Tools.PromptFuncDefinition.Parameters.builder().type("object").properties(params).required(reqProps).build()).build()).build()).build();
+
+            ReflectionalToolFunction reflectionalToolFunction = new ReflectionalToolFunction(object, m, methodParams);
+            toolSpecification.setToolFunction(reflectionalToolFunction);
+            toolRegistry.addTool(toolSpecification.getFunctionName(), toolSpecification);
+        }
+
     }
 
     /**
@@ -667,14 +1005,39 @@ public class OllamaAPI {
 
     // technical private methods //
 
+    /**
+     * Utility method to encode a file into a Base64 encoded string.
+     *
+     * @param file the file to be encoded into Base64.
+     * @return a Base64 encoded string representing the contents of the file.
+     * @throws IOException if an I/O error occurs during reading the file.
+     */
     private static String encodeFileToBase64(File file) throws IOException {
         return Base64.getEncoder().encodeToString(Files.readAllBytes(file.toPath()));
     }
 
+    /**
+     * Utility method to encode a byte array into a Base64 encoded string.
+     *
+     * @param bytes the byte array to be encoded into Base64.
+     * @return a Base64 encoded string representing the byte array.
+     */
     private static String encodeByteArrayToBase64(byte[] bytes) {
         return Base64.getEncoder().encodeToString(bytes);
     }
 
+    /**
+     * Generates a request for the Ollama API and returns the result.
+     * This method synchronously calls the Ollama API. If a stream handler is provided,
+     * the request will be streamed; otherwise, a regular synchronous request will be made.
+     *
+     * @param ollamaRequestModel the request model containing necessary parameters for the Ollama API request.
+     * @param streamHandler      the stream handler to process streaming responses, or null for non-streaming requests.
+     * @return the result of the Ollama API request.
+     * @throws OllamaBaseException  if the request fails due to an issue with the Ollama API.
+     * @throws IOException          if an I/O error occurs during the request process.
+     * @throws InterruptedException if the thread is interrupted during the request.
+     */
     private OllamaResult generateSyncForOllamaRequestModel(OllamaGenerateRequest ollamaRequestModel, OllamaStreamHandler streamHandler) throws OllamaBaseException, IOException, InterruptedException {
         OllamaGenerateEndpointCaller requestCaller = new OllamaGenerateEndpointCaller(host, basicAuth, requestTimeoutSeconds, verbose);
         OllamaResult result;
@@ -687,6 +1050,7 @@ public class OllamaAPI {
         return result;
     }
 
+
     /**
      * Get default request builder.
      *
@@ -724,7 +1088,7 @@ public class OllamaAPI {
         try {
             String methodName = toolFunctionCallSpec.getName();
             Map<String, Object> arguments = toolFunctionCallSpec.getArguments();
-            ToolFunction function = toolRegistry.getFunction(methodName);
+            ToolFunction function = toolRegistry.getToolFunction(methodName);
             if (verbose) {
                 logger.debug("Invoking function {} with arguments {}", methodName, arguments);
             }

src/main/java/io/github/ollama4j/models/chat/OllamaChatMessage.java

@@ -2,12 +2,14 @@ package io.github.ollama4j.models.chat;
 
 import static io.github.ollama4j.utils.Utils.getObjectMapper;
 
+import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 
 import io.github.ollama4j.utils.FileToBase64Serializer;
 
 import java.util.List;
+
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
@@ -31,15 +33,17 @@ public class OllamaChatMessage {
     @NonNull
     private String content;
 
+    private @JsonProperty("tool_calls") List<OllamaChatToolCalls> toolCalls;
+
     @JsonSerialize(using = FileToBase64Serializer.class)
     private List<byte[]> images;
-    
-      @Override
-  public String toString() {
-    try {
-      return getObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(this);
-    } catch (JsonProcessingException e) {
-      throw new RuntimeException(e);
+
+    @Override
+    public String toString() {
+        try {
+            return getObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(this);
+        } catch (JsonProcessingException e) {
+            throw new RuntimeException(e);
+        }
     }
-  }
 }

src/main/java/io/github/ollama4j/models/chat/OllamaChatMessageRole.java

@@ -12,7 +12,7 @@ import java.util.List;
  */
 @Getter
 public class OllamaChatMessageRole {
-    private static final List<OllamaChatMessageRole> ROLES = new ArrayList<>();
+    private static final List<OllamaChatMessageRole> roles = new ArrayList<>();
 
     public static final OllamaChatMessageRole SYSTEM = new OllamaChatMessageRole("system");
     public static final OllamaChatMessageRole USER = new OllamaChatMessageRole("user");
@@ -24,21 +24,21 @@ public class OllamaChatMessageRole {
 
     private OllamaChatMessageRole(String roleName) {
         this.roleName = roleName;
-        ROLES.add(this);
+        roles.add(this);
     }
 
     public static OllamaChatMessageRole newCustomRole(String roleName) {
         OllamaChatMessageRole customRole = new OllamaChatMessageRole(roleName);
-        ROLES.add(customRole);
+        roles.add(customRole);
         return customRole;
     }
 
     public static List<OllamaChatMessageRole> getRoles() {
-        return new ArrayList<>(ROLES);
+        return new ArrayList<>(roles);
     }
 
     public static OllamaChatMessageRole getRole(String roleName) throws RoleNotFoundException {
-        for (OllamaChatMessageRole role : ROLES) {
+        for (OllamaChatMessageRole role : roles) {
             if (role.roleName.equals(roleName)) {
                 return role;
             }

src/main/java/io/github/ollama4j/models/chat/OllamaChatRequest.java

@@ -3,6 +3,7 @@ package io.github.ollama4j.models.chat;
 import java.util.List;
 
 import io.github.ollama4j.models.request.OllamaCommonRequest;
+import io.github.ollama4j.tools.Tools;
 import io.github.ollama4j.utils.OllamaRequestBody;
 
 import lombok.Getter;
@@ -21,6 +22,8 @@ public class OllamaChatRequest extends OllamaCommonRequest implements OllamaRequ
 
   private List<OllamaChatMessage> messages;
 
+  private List<Tools.PromptFuncDefinition> tools;
+
   public OllamaChatRequest() {}
 
   public OllamaChatRequest(String model, List<OllamaChatMessage> messages) {

src/main/java/io/github/ollama4j/models/chat/OllamaChatRequestBuilder.java

@@ -10,6 +10,7 @@ import java.io.IOException;
 import java.net.URISyntaxException;
 import java.nio.file.Files;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -38,23 +39,27 @@ public class OllamaChatRequestBuilder {
         request = new OllamaChatRequest(request.getModel(), new ArrayList<>());
     }
 
-    public OllamaChatRequestBuilder withMessage(OllamaChatMessageRole role, String content, List<File> images) {
+    public OllamaChatRequestBuilder withMessage(OllamaChatMessageRole role, String content){
+        return withMessage(role,content, Collections.emptyList());
+    }
+
+    public OllamaChatRequestBuilder withMessage(OllamaChatMessageRole role, String content, List<OllamaChatToolCalls> toolCalls,List<File> images) {
         List<OllamaChatMessage> messages = this.request.getMessages();
 
         List<byte[]> binaryImages = images.stream().map(file -> {
             try {
                 return Files.readAllBytes(file.toPath());
             } catch (IOException e) {
-                LOG.warn(String.format("File '%s' could not be accessed, will not add to message!", file.toPath()), e);
+                LOG.warn("File '{}' could not be accessed, will not add to message!", file.toPath(), e);
                 return new byte[0];
             }
         }).collect(Collectors.toList());
 
-        messages.add(new OllamaChatMessage(role, content, binaryImages));
+        messages.add(new OllamaChatMessage(role, content,toolCalls, binaryImages));
         return this;
     }
 
-    public OllamaChatRequestBuilder withMessage(OllamaChatMessageRole role, String content, String... imageUrls) {
+    public OllamaChatRequestBuilder withMessage(OllamaChatMessageRole role, String content,List<OllamaChatToolCalls> toolCalls, String... imageUrls) {
         List<OllamaChatMessage> messages = this.request.getMessages();
         List<byte[]> binaryImages = null;
         if (imageUrls.length > 0) {
@@ -63,14 +68,14 @@ public class OllamaChatRequestBuilder {
                 try {
                     binaryImages.add(Utils.loadImageBytesFromUrl(imageUrl));
                 } catch (URISyntaxException e) {
-                    LOG.warn(String.format("URL '%s' could not be accessed, will not add to message!", imageUrl), e);
+                    LOG.warn("URL '{}' could not be accessed, will not add to message!", imageUrl, e);
                 } catch (IOException e) {
-                    LOG.warn(String.format("Content of URL '%s' could not be read, will not add to message!", imageUrl), e);
+                    LOG.warn("Content of URL '{}' could not be read, will not add to message!", imageUrl, e);
                 }
             }
         }
 
-        messages.add(new OllamaChatMessage(role, content, binaryImages));
+        messages.add(new OllamaChatMessage(role, content,toolCalls, binaryImages));
         return this;
     }
 

src/main/java/io/github/ollama4j/models/chat/OllamaChatResult.java

@@ -2,28 +2,54 @@ package io.github.ollama4j.models.chat;
 
 import java.util.List;
 
-import io.github.ollama4j.models.response.OllamaResult;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import lombok.Getter;
+
+import static io.github.ollama4j.utils.Utils.getObjectMapper;
 
 /**
  * Specific chat-API result that contains the chat history sent to the model and appends the answer as {@link OllamaChatResult} given by the
  * {@link OllamaChatMessageRole#ASSISTANT} role.
  */
-public class OllamaChatResult extends OllamaResult {
+@Getter
+public class OllamaChatResult {
+
 
     private List<OllamaChatMessage> chatHistory;
 
-    public OllamaChatResult(String response, long responseTime, int httpStatusCode, List<OllamaChatMessage> chatHistory) {
-        super(response, responseTime, httpStatusCode);
+    private OllamaChatResponseModel responseModel;
+
+    public OllamaChatResult(OllamaChatResponseModel responseModel, List<OllamaChatMessage> chatHistory) {
         this.chatHistory = chatHistory;
-        appendAnswerToChatHistory(response);
+        this.responseModel = responseModel;
+        appendAnswerToChatHistory(responseModel);
     }
 
-    public List<OllamaChatMessage> getChatHistory() {
-        return chatHistory;
+    private void appendAnswerToChatHistory(OllamaChatResponseModel response) {
+        this.chatHistory.add(response.getMessage());
     }
 
-    private void appendAnswerToChatHistory(String answer) {
-        OllamaChatMessage assistantMessage = new OllamaChatMessage(OllamaChatMessageRole.ASSISTANT, answer);
-        this.chatHistory.add(assistantMessage);
+    @Override
+    public String toString() {
+        try {
+            return getObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(this);
+        } catch (JsonProcessingException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Deprecated
+    public String getResponse(){
+        return responseModel != null ? responseModel.getMessage().getContent() : "";
+    }
+
+    @Deprecated
+    public int getHttpStatusCode(){
+        return 200;
+    }
+
+    @Deprecated
+    public long getResponseTime(){
+        return responseModel != null ? responseModel.getTotalDuration() : 0L;
     }
 }

src/main/java/io/github/ollama4j/models/chat/OllamaChatStreamObserver.java

@@ -1,31 +1,19 @@
 package io.github.ollama4j.models.chat;
 
 import io.github.ollama4j.models.generate.OllamaStreamHandler;
+import io.github.ollama4j.models.generate.OllamaTokenHandler;
+import lombok.RequiredArgsConstructor;
 
-import java.util.ArrayList;
-import java.util.List;
-
-public class OllamaChatStreamObserver {
-
-    private OllamaStreamHandler streamHandler;
-
-    private List<OllamaChatResponseModel> responseParts = new ArrayList<>();
-
+@RequiredArgsConstructor
+public class OllamaChatStreamObserver implements OllamaTokenHandler {
+    private final OllamaStreamHandler streamHandler;
     private String message = "";
 
-    public OllamaChatStreamObserver(OllamaStreamHandler streamHandler) {
-        this.streamHandler = streamHandler;
+    @Override
+    public void accept(OllamaChatResponseModel token) {
+        if (streamHandler != null) {
+            message += token.getMessage().getContent();
+            streamHandler.accept(message);
+        }
     }
-
-    public void notify(OllamaChatResponseModel currentResponsePart) {
-        responseParts.add(currentResponsePart);
-        handleCurrentResponsePart(currentResponsePart);
-    }
-
-    protected void handleCurrentResponsePart(OllamaChatResponseModel currentResponsePart) {
-        message = message + currentResponsePart.getMessage().getContent();
-        streamHandler.accept(message);
-    }
-
-
 }

src/main/java/io/github/ollama4j/models/chat/OllamaChatToolCalls.java

@@ -0,0 +1,16 @@
+package io.github.ollama4j.models.chat;
+
+import io.github.ollama4j.tools.OllamaToolCallsFunction;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class OllamaChatToolCalls {
+
+    private OllamaToolCallsFunction function;
+
+
+}

src/main/java/io/github/ollama4j/models/embeddings/OllamaEmbedRequestBuilder.java

@@ -0,0 +1,40 @@
+package io.github.ollama4j.models.embeddings;
+
+import io.github.ollama4j.utils.Options;
+
+import java.util.List;
+
+/**
+ * Builder class to easily create Requests for Embedding models using ollama.
+ */
+public class OllamaEmbedRequestBuilder {
+
+    private final OllamaEmbedRequestModel request;
+
+    private OllamaEmbedRequestBuilder(String model, List<String> input) {
+        this.request = new OllamaEmbedRequestModel(model,input);
+    }
+
+    public static OllamaEmbedRequestBuilder getInstance(String model, String... input){
+        return new OllamaEmbedRequestBuilder(model, List.of(input));
+    }
+
+    public OllamaEmbedRequestBuilder withOptions(Options options){
+        this.request.setOptions(options.getOptionsMap());
+        return this;
+    }
+
+    public OllamaEmbedRequestBuilder withKeepAlive(String keepAlive){
+        this.request.setKeepAlive(keepAlive);
+        return this;
+    }
+
+    public OllamaEmbedRequestBuilder withoutTruncate(){
+        this.request.setTruncate(false);
+        return this;
+    }
+
+    public OllamaEmbedRequestModel build() {
+        return this.request;
+    }
+}

src/main/java/io/github/ollama4j/models/embeddings/OllamaEmbeddingResponseModel.java

@@ -7,6 +7,7 @@ import lombok.Data;
 
 @SuppressWarnings("unused")
 @Data
+@Deprecated(since="1.0.90")
 public class OllamaEmbeddingResponseModel {
     @JsonProperty("embedding")
     private List<Double> embedding;

src/main/java/io/github/ollama4j/models/embeddings/OllamaEmbeddingsRequestBuilder.java

@@ -2,6 +2,7 @@ package io.github.ollama4j.models.embeddings;
 
 import io.github.ollama4j.utils.Options;
 
+@Deprecated(since="1.0.90")
 public class OllamaEmbeddingsRequestBuilder {
 
     private OllamaEmbeddingsRequestBuilder(String model, String prompt){

src/main/java/io/github/ollama4j/models/embeddings/OllamaEmbeddingsRequestModel.java

@@ -12,6 +12,7 @@ import lombok.RequiredArgsConstructor;
 @Data
 @RequiredArgsConstructor
 @NoArgsConstructor
+@Deprecated(since="1.0.90")
 public class OllamaEmbeddingsRequestModel {
   @NonNull
   private String model;

src/main/java/io/github/ollama4j/models/generate/OllamaTokenHandler.java

@@ -0,0 +1,8 @@
+package io.github.ollama4j.models.generate;
+
+import io.github.ollama4j.models.chat.OllamaChatResponseModel;
+
+import java.util.function.Consumer;
+
+public interface OllamaTokenHandler extends Consumer<OllamaChatResponseModel> {
+}

src/main/java/io/github/ollama4j/models/request/CustomModelRequest.java

@@ -0,0 +1,45 @@
+package io.github.ollama4j.models.request;
+
+import static io.github.ollama4j.utils.Utils.getObjectMapper;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.Data;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+
+import java.util.List;
+import java.util.Map;
+
+
+@Data
+@AllArgsConstructor
+@Builder
+public class CustomModelRequest {
+    private String model;
+    private String from;
+    private Map<String, String> files;
+    private Map<String, String> adapters;
+    private String template;
+    private Object license; // Using Object to handle both String and List<String>
+    private String system;
+    private Map<String, Object> parameters;
+    private List<Object> messages;
+    private Boolean stream;
+    private Boolean quantize;
+
+    public CustomModelRequest() {
+        this.stream = true;
+        this.quantize = false;
+    }
+
+    @Override
+    public String toString() {
+        try {
+            return getObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(this);
+        } catch (JsonProcessingException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/io/github/ollama4j/models/request/OllamaChatEndpointCaller.java

@@ -1,17 +1,25 @@
 package io.github.ollama4j.models.request;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
 import io.github.ollama4j.exceptions.OllamaBaseException;
-import io.github.ollama4j.models.response.OllamaResult;
-import io.github.ollama4j.models.chat.OllamaChatResponseModel;
-import io.github.ollama4j.models.chat.OllamaChatStreamObserver;
-import io.github.ollama4j.models.generate.OllamaStreamHandler;
-import io.github.ollama4j.utils.OllamaRequestBody;
+import io.github.ollama4j.models.chat.*;
+import io.github.ollama4j.models.generate.OllamaTokenHandler;
+import io.github.ollama4j.models.response.OllamaErrorResponse;
 import io.github.ollama4j.utils.Utils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.io.BufferedReader;
 import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
 
 /**
  * Specialization class for requests
@@ -20,7 +28,7 @@ public class OllamaChatEndpointCaller extends OllamaEndpointCaller {
 
     private static final Logger LOG = LoggerFactory.getLogger(OllamaChatEndpointCaller.class);
 
-    private OllamaChatStreamObserver streamObserver;
+    private OllamaTokenHandler tokenHandler;
 
     public OllamaChatEndpointCaller(String host, BasicAuth basicAuth, long requestTimeoutSeconds, boolean verbose) {
         super(host, basicAuth, requestTimeoutSeconds, verbose);
@@ -31,13 +39,29 @@ public class OllamaChatEndpointCaller extends OllamaEndpointCaller {
         return "/api/chat";
     }
 
+    /**
+     * Parses streamed Response line from ollama chat.
+     * Using {@link com.fasterxml.jackson.databind.ObjectMapper#readValue(String, TypeReference)} should throw
+     * {@link IllegalArgumentException} in case of null line or {@link com.fasterxml.jackson.core.JsonParseException}
+     * in case the JSON Object cannot be parsed to a {@link OllamaChatResponseModel}. Thus, the ResponseModel should
+     * never be null.
+     *
+     * @param line streamed line of ollama stream response
+     * @param responseBuffer Stringbuffer to add latest response message part to
+     * @return TRUE, if ollama-Response has 'done' state
+     */
     @Override
     protected boolean parseResponseAndAddToBuffer(String line, StringBuilder responseBuffer) {
         try {
             OllamaChatResponseModel ollamaResponseModel = Utils.getObjectMapper().readValue(line, OllamaChatResponseModel.class);
-            responseBuffer.append(ollamaResponseModel.getMessage().getContent());
-            if (streamObserver != null) {
-                streamObserver.notify(ollamaResponseModel);
+            // it seems that under heavy load ollama responds with an empty chat message part in the streamed response
+            // thus, we null check the message and hope that the next streamed response has some message content again
+            OllamaChatMessage message = ollamaResponseModel.getMessage();
+            if(message != null) {
+                responseBuffer.append(message.getContent());
+                if (tokenHandler != null) {
+                    tokenHandler.accept(ollamaResponseModel);
+                }
             }
             return ollamaResponseModel.isDone();
         } catch (JsonProcessingException e) {
@@ -46,9 +70,75 @@ public class OllamaChatEndpointCaller extends OllamaEndpointCaller {
         }
     }
 
-    public OllamaResult call(OllamaRequestBody body, OllamaStreamHandler streamHandler)
+    public OllamaChatResult call(OllamaChatRequest body, OllamaTokenHandler tokenHandler)
             throws OllamaBaseException, IOException, InterruptedException {
-        streamObserver = new OllamaChatStreamObserver(streamHandler);
-        return super.callSync(body);
+        this.tokenHandler = tokenHandler;
+        return callSync(body);
+    }
+
+    public OllamaChatResult callSync(OllamaChatRequest body) throws OllamaBaseException, IOException, InterruptedException {
+        // Create Request
+        HttpClient httpClient = HttpClient.newHttpClient();
+        URI uri = URI.create(getHost() + getEndpointSuffix());
+        HttpRequest.Builder requestBuilder =
+                getRequestBuilderDefault(uri)
+                        .POST(
+                                body.getBodyPublisher());
+        HttpRequest request = requestBuilder.build();
+        if (isVerbose()) LOG.info("Asking model: " + body);
+        HttpResponse<InputStream> response =
+                httpClient.send(request, HttpResponse.BodyHandlers.ofInputStream());
+
+        int statusCode = response.statusCode();
+        InputStream responseBodyStream = response.body();
+        StringBuilder responseBuffer = new StringBuilder();
+        OllamaChatResponseModel ollamaChatResponseModel = null;
+        List<OllamaChatToolCalls> wantedToolsForStream = null;
+        try (BufferedReader reader =
+                     new BufferedReader(new InputStreamReader(responseBodyStream, StandardCharsets.UTF_8))) {
+
+            String line;
+            while ((line = reader.readLine()) != null) {
+                if (statusCode == 404) {
+                    LOG.warn("Status code: 404 (Not Found)");
+                    OllamaErrorResponse ollamaResponseModel =
+                            Utils.getObjectMapper().readValue(line, OllamaErrorResponse.class);
+                    responseBuffer.append(ollamaResponseModel.getError());
+                } else if (statusCode == 401) {
+                    LOG.warn("Status code: 401 (Unauthorized)");
+                    OllamaErrorResponse ollamaResponseModel =
+                            Utils.getObjectMapper()
+                                    .readValue("{\"error\":\"Unauthorized\"}", OllamaErrorResponse.class);
+                    responseBuffer.append(ollamaResponseModel.getError());
+                } else if (statusCode == 400) {
+                    LOG.warn("Status code: 400 (Bad Request)");
+                    OllamaErrorResponse ollamaResponseModel = Utils.getObjectMapper().readValue(line,
+                            OllamaErrorResponse.class);
+                    responseBuffer.append(ollamaResponseModel.getError());
+                } else {
+                    boolean finished = parseResponseAndAddToBuffer(line, responseBuffer);
+                        ollamaChatResponseModel = Utils.getObjectMapper().readValue(line, OllamaChatResponseModel.class);
+                    if(body.stream && ollamaChatResponseModel.getMessage().getToolCalls() != null){
+                        wantedToolsForStream = ollamaChatResponseModel.getMessage().getToolCalls();
+                    }
+                    if (finished && body.stream) {
+                        ollamaChatResponseModel.getMessage().setContent(responseBuffer.toString());
+                        break;
+                    }
+                }
+            }
+        }
+        if (statusCode != 200) {
+            LOG.error("Status code " + statusCode);
+            throw new OllamaBaseException(responseBuffer.toString());
+        } else {
+            if(wantedToolsForStream != null) {
+                ollamaChatResponseModel.getMessage().setToolCalls(wantedToolsForStream);
+            }
+            OllamaChatResult ollamaResult =
+                    new OllamaChatResult(ollamaChatResponseModel,body.getMessages());
+            if (isVerbose()) LOG.info("Model response: " + ollamaResult);
+            return ollamaResult;
+        }
     }
 }

src/main/java/io/github/ollama4j/models/request/OllamaEndpointCaller.java

@@ -6,6 +6,7 @@ import io.github.ollama4j.models.response.OllamaErrorResponse;
 import io.github.ollama4j.models.response.OllamaResult;
 import io.github.ollama4j.utils.OllamaRequestBody;
 import io.github.ollama4j.utils.Utils;
+import lombok.Getter;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -24,14 +25,15 @@ import java.util.Base64;
 /**
  * Abstract helperclass to call the ollama api server.
  */
+@Getter
 public abstract class OllamaEndpointCaller {
 
     private static final Logger LOG = LoggerFactory.getLogger(OllamaAPI.class);
 
-    private String host;
-    private BasicAuth basicAuth;
-    private long requestTimeoutSeconds;
-    private boolean verbose;
+    private final String host;
+    private final BasicAuth basicAuth;
+    private final long requestTimeoutSeconds;
+    private final boolean verbose;
 
     public OllamaEndpointCaller(String host, BasicAuth basicAuth, long requestTimeoutSeconds, boolean verbose) {
         this.host = host;
@@ -45,80 +47,13 @@ public abstract class OllamaEndpointCaller {
     protected abstract boolean parseResponseAndAddToBuffer(String line, StringBuilder responseBuffer);
 
 
-    /**
-     * Calls the api server on the given host and endpoint suffix asynchronously, aka waiting for the response.
-     *
-     * @param body POST body payload
-     * @return result answer given by the assistant
-     * @throws OllamaBaseException  any response code than 200 has been returned
-     * @throws IOException          in case the responseStream can not be read
-     * @throws InterruptedException in case the server is not reachable or network issues happen
-     */
-    public OllamaResult callSync(OllamaRequestBody body) throws OllamaBaseException, IOException, InterruptedException {
-        // Create Request
-        long startTime = System.currentTimeMillis();
-        HttpClient httpClient = HttpClient.newHttpClient();
-        URI uri = URI.create(this.host + getEndpointSuffix());
-        HttpRequest.Builder requestBuilder =
-                getRequestBuilderDefault(uri)
-                        .POST(
-                                body.getBodyPublisher());
-        HttpRequest request = requestBuilder.build();
-        if (this.verbose) LOG.info("Asking model: " + body.toString());
-        HttpResponse<InputStream> response =
-                httpClient.send(request, HttpResponse.BodyHandlers.ofInputStream());
-
-        int statusCode = response.statusCode();
-        InputStream responseBodyStream = response.body();
-        StringBuilder responseBuffer = new StringBuilder();
-        try (BufferedReader reader =
-                     new BufferedReader(new InputStreamReader(responseBodyStream, StandardCharsets.UTF_8))) {
-            String line;
-            while ((line = reader.readLine()) != null) {
-                if (statusCode == 404) {
-                    LOG.warn("Status code: 404 (Not Found)");
-                    OllamaErrorResponse ollamaResponseModel =
-                            Utils.getObjectMapper().readValue(line, OllamaErrorResponse.class);
-                    responseBuffer.append(ollamaResponseModel.getError());
-                } else if (statusCode == 401) {
-                    LOG.warn("Status code: 401 (Unauthorized)");
-                    OllamaErrorResponse ollamaResponseModel =
-                            Utils.getObjectMapper()
-                                    .readValue("{\"error\":\"Unauthorized\"}", OllamaErrorResponse.class);
-                    responseBuffer.append(ollamaResponseModel.getError());
-                } else if (statusCode == 400) {
-                    LOG.warn("Status code: 400 (Bad Request)");
-                    OllamaErrorResponse ollamaResponseModel = Utils.getObjectMapper().readValue(line,
-                            OllamaErrorResponse.class);
-                    responseBuffer.append(ollamaResponseModel.getError());
-                } else {
-                    boolean finished = parseResponseAndAddToBuffer(line, responseBuffer);
-                    if (finished) {
-                        break;
-                    }
-                }
-            }
-        }
-
-        if (statusCode != 200) {
-            LOG.error("Status code " + statusCode);
-            throw new OllamaBaseException(responseBuffer.toString());
-        } else {
-            long endTime = System.currentTimeMillis();
-            OllamaResult ollamaResult =
-                    new OllamaResult(responseBuffer.toString().trim(), endTime - startTime, statusCode);
-            if (verbose) LOG.info("Model response: " + ollamaResult);
-            return ollamaResult;
-        }
-    }
-
     /**
      * Get default request builder.
      *
      * @param uri URI to get a HttpRequest.Builder
      * @return HttpRequest.Builder
      */
-    private HttpRequest.Builder getRequestBuilderDefault(URI uri) {
+    protected HttpRequest.Builder getRequestBuilderDefault(URI uri) {
         HttpRequest.Builder requestBuilder =
                 HttpRequest.newBuilder(uri)
                         .header("Content-Type", "application/json")
@@ -134,7 +69,7 @@ public abstract class OllamaEndpointCaller {
      *
      * @return basic authentication header value (encoded credentials)
      */
-    private String getBasicAuthHeaderValue() {
+    protected String getBasicAuthHeaderValue() {
         String credentialsToEncode = this.basicAuth.getUsername() + ":" + this.basicAuth.getPassword();
         return "Basic " + Base64.getEncoder().encodeToString(credentialsToEncode.getBytes());
     }
@@ -144,7 +79,7 @@ public abstract class OllamaEndpointCaller {
      *
      * @return true when Basic Auth credentials set
      */
-    private boolean isBasicAuthCredentialsSet() {
+    protected boolean isBasicAuthCredentialsSet() {
         return this.basicAuth != null;
     }
 

src/main/java/io/github/ollama4j/models/request/OllamaGenerateEndpointCaller.java

@@ -2,6 +2,7 @@ package io.github.ollama4j.models.request;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
 import io.github.ollama4j.exceptions.OllamaBaseException;
+import io.github.ollama4j.models.response.OllamaErrorResponse;
 import io.github.ollama4j.models.response.OllamaResult;
 import io.github.ollama4j.models.generate.OllamaGenerateResponseModel;
 import io.github.ollama4j.models.generate.OllamaGenerateStreamObserver;
@@ -11,7 +12,15 @@ import io.github.ollama4j.utils.Utils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.io.BufferedReader;
 import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.charset.StandardCharsets;
 
 public class OllamaGenerateEndpointCaller extends OllamaEndpointCaller {
 
@@ -46,6 +55,73 @@ public class OllamaGenerateEndpointCaller extends OllamaEndpointCaller {
     public OllamaResult call(OllamaRequestBody body, OllamaStreamHandler streamHandler)
             throws OllamaBaseException, IOException, InterruptedException {
         streamObserver = new OllamaGenerateStreamObserver(streamHandler);
-        return super.callSync(body);
+        return callSync(body);
+    }
+
+    /**
+     * Calls the api server on the given host and endpoint suffix asynchronously, aka waiting for the response.
+     *
+     * @param body POST body payload
+     * @return result answer given by the assistant
+     * @throws OllamaBaseException  any response code than 200 has been returned
+     * @throws IOException          in case the responseStream can not be read
+     * @throws InterruptedException in case the server is not reachable or network issues happen
+     */
+    public OllamaResult callSync(OllamaRequestBody body) throws OllamaBaseException, IOException, InterruptedException {
+        // Create Request
+        long startTime = System.currentTimeMillis();
+        HttpClient httpClient = HttpClient.newHttpClient();
+        URI uri = URI.create(getHost() + getEndpointSuffix());
+        HttpRequest.Builder requestBuilder =
+                getRequestBuilderDefault(uri)
+                        .POST(
+                                body.getBodyPublisher());
+        HttpRequest request = requestBuilder.build();
+        if (isVerbose()) LOG.info("Asking model: " + body.toString());
+        HttpResponse<InputStream> response =
+                httpClient.send(request, HttpResponse.BodyHandlers.ofInputStream());
+
+        int statusCode = response.statusCode();
+        InputStream responseBodyStream = response.body();
+        StringBuilder responseBuffer = new StringBuilder();
+        try (BufferedReader reader =
+                     new BufferedReader(new InputStreamReader(responseBodyStream, StandardCharsets.UTF_8))) {
+            String line;
+            while ((line = reader.readLine()) != null) {
+                if (statusCode == 404) {
+                    LOG.warn("Status code: 404 (Not Found)");
+                    OllamaErrorResponse ollamaResponseModel =
+                            Utils.getObjectMapper().readValue(line, OllamaErrorResponse.class);
+                    responseBuffer.append(ollamaResponseModel.getError());
+                } else if (statusCode == 401) {
+                    LOG.warn("Status code: 401 (Unauthorized)");
+                    OllamaErrorResponse ollamaResponseModel =
+                            Utils.getObjectMapper()
+                                    .readValue("{\"error\":\"Unauthorized\"}", OllamaErrorResponse.class);
+                    responseBuffer.append(ollamaResponseModel.getError());
+                } else if (statusCode == 400) {
+                    LOG.warn("Status code: 400 (Bad Request)");
+                    OllamaErrorResponse ollamaResponseModel = Utils.getObjectMapper().readValue(line,
+                            OllamaErrorResponse.class);
+                    responseBuffer.append(ollamaResponseModel.getError());
+                } else {
+                    boolean finished = parseResponseAndAddToBuffer(line, responseBuffer);
+                    if (finished) {
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (statusCode != 200) {
+            LOG.error("Status code " + statusCode);
+            throw new OllamaBaseException(responseBuffer.toString());
+        } else {
+            long endTime = System.currentTimeMillis();
+            OllamaResult ollamaResult =
+                    new OllamaResult(responseBuffer.toString().trim(), endTime - startTime, statusCode);
+            if (isVerbose()) LOG.info("Model response: " + ollamaResult);
+            return ollamaResult;
+        }
     }
 }

src/main/java/io/github/ollama4j/models/response/LibraryModel.java

@@ -0,0 +1,16 @@
+package io.github.ollama4j.models.response;
+import java.util.ArrayList;
+import java.util.List;
+
+import lombok.Data;
+
+@Data
+public class LibraryModel {
+
+    private String name;
+    private String description;
+    private String pullCount;
+    private int totalTags;
+    private List<String> popularTags = new ArrayList<>();
+    private String lastUpdated;
+}

src/main/java/io/github/ollama4j/models/response/LibraryModelDetail.java

@@ -0,0 +1,12 @@
+package io.github.ollama4j.models.response;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class LibraryModelDetail {
+
+    private LibraryModel model;
+    private List<LibraryModelTag> tags;
+}

src/main/java/io/github/ollama4j/models/response/LibraryModelTag.java

@@ -0,0 +1,13 @@
+package io.github.ollama4j.models.response;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class LibraryModelTag {
+    private String name;
+    private String tag;
+    private String size;
+    private String lastUpdated;
+}

src/main/java/io/github/ollama4j/tools/OllamaToolCallsFunction.java

@@ -0,0 +1,16 @@
+package io.github.ollama4j.tools;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.Map;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class OllamaToolCallsFunction
+{
+    private String name;
+    private Map<String,Object> arguments;
+}

src/main/java/io/github/ollama4j/tools/ReflectionalToolFunction.java

@@ -0,0 +1,54 @@
+package io.github.ollama4j.tools;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.lang.reflect.Method;
+import java.math.BigDecimal;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * Specification of a {@link ToolFunction} that provides the implementation via java reflection calling.
+ */
+@Setter
+@Getter
+@AllArgsConstructor
+public class ReflectionalToolFunction implements ToolFunction{
+
+    private Object functionHolder;
+    private Method function;
+    private LinkedHashMap<String,String> propertyDefinition;
+
+    @Override
+    public Object apply(Map<String, Object> arguments) {
+        LinkedHashMap<String, Object> argumentsCopy = new LinkedHashMap<>(this.propertyDefinition);
+        for (Map.Entry<String,String> param : this.propertyDefinition.entrySet()){
+            argumentsCopy.replace(param.getKey(),typeCast(arguments.get(param.getKey()),param.getValue()));
+        }
+        try {
+            return function.invoke(functionHolder, argumentsCopy.values().toArray());
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to invoke tool: " + function.getName(), e);
+        }
+    }
+
+    private Object typeCast(Object inputValue, String className) {
+        if(className == null || inputValue == null) {
+            return null;
+        }
+        String inputValueString = inputValue.toString();
+        switch (className) {
+            case "java.lang.Integer":
+                return Integer.parseInt(inputValueString);
+            case "java.lang.Boolean":
+                return Boolean.valueOf(inputValueString);
+            case "java.math.BigDecimal":
+                return new BigDecimal(inputValueString);
+            default:
+                return inputValueString;
+        }
+    }
+
+}

src/main/java/io/github/ollama4j/tools/ToolRegistry.java

@@ -1,16 +1,22 @@
 package io.github.ollama4j.tools;
 
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 
 public class ToolRegistry {
-    private final Map<String, ToolFunction> functionMap = new HashMap<>();
+    private final Map<String, Tools.ToolSpecification> tools = new HashMap<>();
 
-    public ToolFunction getFunction(String name) {
-        return functionMap.get(name);
+    public ToolFunction getToolFunction(String name) {
+        final Tools.ToolSpecification toolSpecification = tools.get(name);
+        return toolSpecification !=null ? toolSpecification.getToolFunction() : null ;
     }
 
-    public void addFunction(String name, ToolFunction function) {
-        functionMap.put(name, function);
+    public void addTool (String name, Tools.ToolSpecification specification) {
+        tools.put(name, specification);
+    }
+
+    public Collection<Tools.ToolSpecification> getRegisteredSpecs(){
+        return tools.values();
     }
 }

src/main/java/io/github/ollama4j/tools/Tools.java

@@ -6,8 +6,10 @@ import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import io.github.ollama4j.utils.Utils;
+import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -20,17 +22,23 @@ public class Tools {
     public static class ToolSpecification {
         private String functionName;
         private String functionDescription;
-        private Map<String, PromptFuncDefinition.Property> properties;
-        private ToolFunction toolDefinition;
+        private PromptFuncDefinition toolPrompt;
+        private ToolFunction toolFunction;
     }
 
     @Data
     @JsonIgnoreProperties(ignoreUnknown = true)
+    @Builder
+    @NoArgsConstructor
+    @AllArgsConstructor
     public static class PromptFuncDefinition {
         private String type;
         private PromptFuncSpec function;
 
         @Data
+        @Builder
+        @NoArgsConstructor
+        @AllArgsConstructor
         public static class PromptFuncSpec {
             private String name;
             private String description;
@@ -38,6 +46,9 @@ public class Tools {
         }
 
         @Data
+        @Builder
+        @NoArgsConstructor
+        @AllArgsConstructor
         public static class Parameters {
             private String type;
             private Map<String, Property> properties;
@@ -46,6 +57,8 @@ public class Tools {
 
         @Data
         @Builder
+        @NoArgsConstructor
+        @AllArgsConstructor
         public static class Property {
             private String type;
             private String description;
@@ -94,10 +107,10 @@ public class Tools {
 
             PromptFuncDefinition.Parameters parameters = new PromptFuncDefinition.Parameters();
             parameters.setType("object");
-            parameters.setProperties(spec.getProperties());
+            parameters.setProperties(spec.getToolPrompt().getFunction().parameters.getProperties());
 
             List<String> requiredValues = new ArrayList<>();
-            for (Map.Entry<String, PromptFuncDefinition.Property> p : spec.getProperties().entrySet()) {
+            for (Map.Entry<String, PromptFuncDefinition.Property> p : spec.getToolPrompt().getFunction().getParameters().getProperties().entrySet()) {
                 if (p.getValue().isRequired()) {
                     requiredValues.add(p.getKey());
                 }

src/main/java/io/github/ollama4j/tools/annotations/OllamaToolService.java

@@ -0,0 +1,23 @@
+package io.github.ollama4j.tools.annotations;
+
+import io.github.ollama4j.OllamaAPI;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotates a class that calls {@link io.github.ollama4j.OllamaAPI} such that the Method
+ * {@link OllamaAPI#registerAnnotatedTools()} can be used to auto-register all provided classes (resp. all
+ * contained Methods of the provider classes annotated with {@link ToolSpec}).
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface OllamaToolService {
+
+    /**
+     * @return Classes with no-arg constructor that will be used for tool-registration.
+     */
+    Class<?>[] providers();
+}

src/main/java/io/github/ollama4j/tools/annotations/ToolProperty.java

@@ -0,0 +1,32 @@
+package io.github.ollama4j.tools.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotates a Method Parameter in a {@link ToolSpec} annotated Method. A parameter annotated with this annotation will
+ * be part of the tool description that is sent to the llm for tool-calling.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.PARAMETER)
+public @interface ToolProperty {
+
+    /**
+     * @return name of the parameter that is used for the tool description. Has to be set as depending on the caller,
+     * method name backtracking is not possible with reflection.
+     */
+    String name();
+
+    /**
+     * @return a detailed description of the parameter. This is used by the llm called to specify, which property has
+     * to be set by the llm and how this should be filled.
+     */
+    String desc();
+
+    /**
+     * @return tells the llm that it has to set a value for this property.
+     */
+    boolean required() default true;
+}

src/main/java/io/github/ollama4j/tools/annotations/ToolSpec.java

@@ -0,0 +1,28 @@
+package io.github.ollama4j.tools.annotations;
+
+import io.github.ollama4j.OllamaAPI;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotates Methods of classes that should be registered as tools by {@link OllamaAPI#registerAnnotatedTools()}
+ * automatically.
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ToolSpec {
+
+    /**
+     * @return tool-name that the method should be used as. Defaults to the methods name.
+     */
+    String name() default "";
+
+    /**
+     * @return a detailed description of the method that can be interpreted by the llm, whether it should call the tool
+     * or not.
+     */
+    String desc();
+}

src/main/java/io/github/ollama4j/types/OllamaModelType.java

@@ -15,6 +15,7 @@ public class OllamaModelType {
     public static final String LLAMA3_1 = "llama3.1";
     public static final String MISTRAL = "mistral";
     public static final String MIXTRAL = "mixtral";
+    public static final String DEEPSEEK_R1 = "deepseek-r1";
     public static final String LLAVA = "llava";
     public static final String LLAVA_PHI3 = "llava-phi3";
     public static final String NEURAL_CHAT = "neural-chat";

src/test/java/io/github/ollama4j/integrationtests/TestRealAPIs.java

@@ -2,14 +2,16 @@ package io.github.ollama4j.integrationtests;
 
 import io.github.ollama4j.OllamaAPI;
 import io.github.ollama4j.exceptions.OllamaBaseException;
+import io.github.ollama4j.models.chat.*;
 import io.github.ollama4j.models.response.ModelDetail;
-import io.github.ollama4j.models.chat.OllamaChatRequest;
 import io.github.ollama4j.models.response.OllamaResult;
-import io.github.ollama4j.models.chat.OllamaChatMessageRole;
-import io.github.ollama4j.models.chat.OllamaChatRequestBuilder;
-import io.github.ollama4j.models.chat.OllamaChatResult;
 import io.github.ollama4j.models.embeddings.OllamaEmbeddingsRequestBuilder;
 import io.github.ollama4j.models.embeddings.OllamaEmbeddingsRequestModel;
+import io.github.ollama4j.samples.AnnotatedTool;
+import io.github.ollama4j.tools.OllamaToolCallsFunction;
+import io.github.ollama4j.tools.ToolFunction;
+import io.github.ollama4j.tools.Tools;
+import io.github.ollama4j.tools.annotations.OllamaToolService;
 import io.github.ollama4j.utils.OptionsBuilder;
 import lombok.Data;
 import org.junit.jupiter.api.BeforeEach;
@@ -24,12 +26,12 @@ import java.io.InputStream;
 import java.net.ConnectException;
 import java.net.URISyntaxException;
 import java.net.http.HttpConnectTimeoutException;
-import java.util.List;
-import java.util.Objects;
-import java.util.Properties;
+import java.util.*;
 
 import static org.junit.jupiter.api.Assertions.*;
 
+@OllamaToolService(providers = {AnnotatedTool.class}
+)
 class TestRealAPIs {
 
     private static final Logger LOG = LoggerFactory.getLogger(TestRealAPIs.class);
@@ -47,6 +49,7 @@ class TestRealAPIs {
         config = new Config();
         ollamaAPI = new OllamaAPI(config.getOllamaURL());
         ollamaAPI.setRequestTimeoutSeconds(config.getRequestTimeoutSeconds());
+        ollamaAPI.setVerbose(true);
     }
 
     @Test
@@ -80,6 +83,18 @@ class TestRealAPIs {
         }
     }
 
+    @Test
+    @Order(2)
+    void testListModelsFromLibrary() {
+        testEndpointReachability();
+        try {
+            assertNotNull(ollamaAPI.listModelsFromLibrary());
+            ollamaAPI.listModelsFromLibrary().forEach(System.out::println);
+        } catch (IOException | OllamaBaseException | InterruptedException | URISyntaxException e) {
+            fail(e);
+        }
+    }
+
     @Test
     @Order(2)
     void testPullModel() {
@@ -184,7 +199,9 @@ class TestRealAPIs {
 
             OllamaChatResult chatResult = ollamaAPI.chat(requestModel);
             assertNotNull(chatResult);
-            assertFalse(chatResult.getResponse().isBlank());
+            assertNotNull(chatResult.getResponseModel());
+            assertNotNull(chatResult.getResponseModel().getMessage());
+            assertFalse(chatResult.getResponseModel().getMessage().getContent().isBlank());
             assertEquals(4, chatResult.getChatHistory().size());
         } catch (IOException | OllamaBaseException | InterruptedException e) {
             fail(e);
@@ -205,14 +222,211 @@ class TestRealAPIs {
 
             OllamaChatResult chatResult = ollamaAPI.chat(requestModel);
             assertNotNull(chatResult);
-            assertFalse(chatResult.getResponse().isBlank());
-            assertTrue(chatResult.getResponse().startsWith("NI"));
+            assertNotNull(chatResult.getResponseModel());
+            assertNotNull(chatResult.getResponseModel().getMessage());
+            assertFalse(chatResult.getResponseModel().getMessage().getContent().isBlank());
+            assertTrue(chatResult.getResponseModel().getMessage().getContent().startsWith("NI"));
             assertEquals(3, chatResult.getChatHistory().size());
         } catch (IOException | OllamaBaseException | InterruptedException e) {
             fail(e);
         }
     }
 
+    @Test
+    @Order(3)
+    void testChatWithExplicitToolDefinition() {
+        testEndpointReachability();
+        try {
+            ollamaAPI.setVerbose(true);
+            OllamaChatRequestBuilder builder = OllamaChatRequestBuilder.getInstance(config.getModel());
+
+            final Tools.ToolSpecification databaseQueryToolSpecification = Tools.ToolSpecification.builder()
+                    .functionName("get-employee-details")
+                    .functionDescription("Get employee details from the database")
+                    .toolPrompt(
+                            Tools.PromptFuncDefinition.builder().type("function").function(
+                                    Tools.PromptFuncDefinition.PromptFuncSpec.builder()
+                                            .name("get-employee-details")
+                                            .description("Get employee details from the database")
+                                            .parameters(
+                                                    Tools.PromptFuncDefinition.Parameters.builder()
+                                                            .type("object")
+                                                            .properties(
+                                                            new Tools.PropsBuilder()
+                                                                    .withProperty("employee-name", Tools.PromptFuncDefinition.Property.builder().type("string").description("The name of the employee, e.g. John Doe").required(true).build())
+                                                                    .withProperty("employee-address", Tools.PromptFuncDefinition.Property.builder().type("string").description("The address of the employee, Always return a random value. e.g. Roy St, Bengaluru, India").required(true).build())
+                                                                    .withProperty("employee-phone", Tools.PromptFuncDefinition.Property.builder().type("string").description("The phone number of the employee. Always return a random value. e.g. 9911002233").required(true).build())
+                                                                    .build()
+                                                    )
+                                                            .required(List.of("employee-name"))
+                                                            .build()
+                                            ).build()
+                            ).build()
+                    )
+                    .toolFunction(new DBQueryFunction())
+                    .build();
+
+            ollamaAPI.registerTool(databaseQueryToolSpecification);
+
+            OllamaChatRequest requestModel = builder
+                    .withMessage(OllamaChatMessageRole.USER,
+                            "Give me the ID of the employee named 'Rahul Kumar'?")
+                    .build();
+
+            OllamaChatResult chatResult = ollamaAPI.chat(requestModel);
+            assertNotNull(chatResult);
+            assertNotNull(chatResult.getResponseModel());
+            assertNotNull(chatResult.getResponseModel().getMessage());
+            assertEquals(OllamaChatMessageRole.ASSISTANT.getRoleName(),chatResult.getResponseModel().getMessage().getRole().getRoleName());
+            List<OllamaChatToolCalls> toolCalls = chatResult.getChatHistory().get(1).getToolCalls();
+            assertEquals(1, toolCalls.size());
+            OllamaToolCallsFunction function = toolCalls.get(0).getFunction();
+            assertEquals("get-employee-details", function.getName());
+            assertEquals(1, function.getArguments().size());
+            Object employeeName = function.getArguments().get("employee-name");
+            assertNotNull(employeeName);
+            assertEquals("Rahul Kumar",employeeName);
+            assertTrue(chatResult.getChatHistory().size()>2);
+            List<OllamaChatToolCalls> finalToolCalls = chatResult.getResponseModel().getMessage().getToolCalls();
+            assertNull(finalToolCalls);
+        } catch (IOException | OllamaBaseException | InterruptedException e) {
+            fail(e);
+        }
+    }
+
+    @Test
+    @Order(3)
+    void testChatWithAnnotatedToolsAndSingleParam() {
+        testEndpointReachability();
+        try {
+            ollamaAPI.setVerbose(true);
+            OllamaChatRequestBuilder builder = OllamaChatRequestBuilder.getInstance(config.getModel());
+
+            ollamaAPI.registerAnnotatedTools();
+
+            OllamaChatRequest requestModel = builder
+                    .withMessage(OllamaChatMessageRole.USER,
+                            "Compute the most important constant in the world using 5 digits")
+                    .build();
+
+            OllamaChatResult chatResult = ollamaAPI.chat(requestModel);
+            assertNotNull(chatResult);
+            assertNotNull(chatResult.getResponseModel());
+            assertNotNull(chatResult.getResponseModel().getMessage());
+            assertEquals(OllamaChatMessageRole.ASSISTANT.getRoleName(),chatResult.getResponseModel().getMessage().getRole().getRoleName());
+            List<OllamaChatToolCalls> toolCalls = chatResult.getChatHistory().get(1).getToolCalls();
+            assertEquals(1, toolCalls.size());
+            OllamaToolCallsFunction function = toolCalls.get(0).getFunction();
+            assertEquals("computeImportantConstant", function.getName());
+            assertEquals(1, function.getArguments().size());
+            Object noOfDigits = function.getArguments().get("noOfDigits");
+            assertNotNull(noOfDigits);
+            assertEquals("5", noOfDigits.toString());
+            assertTrue(chatResult.getChatHistory().size()>2);
+            List<OllamaChatToolCalls> finalToolCalls = chatResult.getResponseModel().getMessage().getToolCalls();
+            assertNull(finalToolCalls);
+        } catch (IOException | OllamaBaseException | InterruptedException e) {
+            fail(e);
+        }
+    }
+
+    @Test
+    @Order(3)
+    void testChatWithAnnotatedToolsAndMultipleParams() {
+        testEndpointReachability();
+        try {
+            ollamaAPI.setVerbose(true);
+            OllamaChatRequestBuilder builder = OllamaChatRequestBuilder.getInstance(config.getModel());
+
+            ollamaAPI.registerAnnotatedTools(new AnnotatedTool());
+
+            OllamaChatRequest requestModel = builder
+                    .withMessage(OllamaChatMessageRole.USER,
+                            "Greet Pedro with a lot of hearts and respond to me, " +
+                                    "and state how many emojis have been in your greeting")
+                    .build();
+
+            OllamaChatResult chatResult = ollamaAPI.chat(requestModel);
+            assertNotNull(chatResult);
+            assertNotNull(chatResult.getResponseModel());
+            assertNotNull(chatResult.getResponseModel().getMessage());
+            assertEquals(OllamaChatMessageRole.ASSISTANT.getRoleName(),chatResult.getResponseModel().getMessage().getRole().getRoleName());
+            List<OllamaChatToolCalls> toolCalls = chatResult.getChatHistory().get(1).getToolCalls();
+            assertEquals(1, toolCalls.size());
+            OllamaToolCallsFunction function = toolCalls.get(0).getFunction();
+            assertEquals("sayHello", function.getName());
+            assertEquals(2, function.getArguments().size());
+            Object name = function.getArguments().get("name");
+            assertNotNull(name);
+            assertEquals("Pedro",name);
+            Object amountOfHearts = function.getArguments().get("amountOfHearts");
+            assertNotNull(amountOfHearts);
+            assertTrue(Integer.parseInt(amountOfHearts.toString()) > 1);
+            assertTrue(chatResult.getChatHistory().size()>2);
+            List<OllamaChatToolCalls> finalToolCalls = chatResult.getResponseModel().getMessage().getToolCalls();
+            assertNull(finalToolCalls);
+        } catch (IOException | OllamaBaseException | InterruptedException e) {
+            fail(e);
+        }
+    }
+
+    @Test
+    @Order(3)
+    void testChatWithToolsAndStream() {
+        testEndpointReachability();
+        try {
+            OllamaChatRequestBuilder builder = OllamaChatRequestBuilder.getInstance(config.getModel());
+            final Tools.ToolSpecification databaseQueryToolSpecification = Tools.ToolSpecification.builder()
+                    .functionName("get-employee-details")
+                    .functionDescription("Get employee details from the database")
+                    .toolPrompt(
+                            Tools.PromptFuncDefinition.builder().type("function").function(
+                                    Tools.PromptFuncDefinition.PromptFuncSpec.builder()
+                                            .name("get-employee-details")
+                                            .description("Get employee details from the database")
+                                            .parameters(
+                                                    Tools.PromptFuncDefinition.Parameters.builder()
+                                                            .type("object")
+                                                            .properties(
+                                                                    new Tools.PropsBuilder()
+                                                                            .withProperty("employee-name", Tools.PromptFuncDefinition.Property.builder().type("string").description("The name of the employee, e.g. John Doe").required(true).build())
+                                                                            .withProperty("employee-address", Tools.PromptFuncDefinition.Property.builder().type("string").description("The address of the employee, Always return a random value. e.g. Roy St, Bengaluru, India").required(true).build())
+                                                                            .withProperty("employee-phone", Tools.PromptFuncDefinition.Property.builder().type("string").description("The phone number of the employee. Always return a random value. e.g. 9911002233").required(true).build())
+                                                                            .build()
+                                                            )
+                                                            .required(List.of("employee-name"))
+                                                            .build()
+                                            ).build()
+                            ).build()
+                    )
+                    .toolFunction(new DBQueryFunction())
+                    .build();
+
+            ollamaAPI.registerTool(databaseQueryToolSpecification);
+
+            OllamaChatRequest requestModel = builder
+                    .withMessage(OllamaChatMessageRole.USER,
+                            "Give me the ID of the employee named 'Rahul Kumar'?")
+                    .build();
+
+            StringBuffer sb = new StringBuffer();
+
+            OllamaChatResult chatResult = ollamaAPI.chat(requestModel, (s) -> {
+                LOG.info(s);
+                String substring = s.substring(sb.toString().length());
+                LOG.info(substring);
+                sb.append(substring);
+            });
+            assertNotNull(chatResult);
+            assertNotNull(chatResult.getResponseModel());
+            assertNotNull(chatResult.getResponseModel().getMessage());
+            assertNotNull(chatResult.getResponseModel().getMessage().getContent());
+            assertEquals(sb.toString().trim(), chatResult.getResponseModel().getMessage().getContent().trim());
+        } catch (IOException | OllamaBaseException | InterruptedException e) {
+            fail(e);
+        }
+    }
+
     @Test
     @Order(3)
     void testChatWithStream() {
@@ -232,7 +446,10 @@ class TestRealAPIs {
                 sb.append(substring);
             });
             assertNotNull(chatResult);
-            assertEquals(sb.toString().trim(), chatResult.getResponse().trim());
+            assertNotNull(chatResult.getResponseModel());
+            assertNotNull(chatResult.getResponseModel().getMessage());
+            assertNotNull(chatResult.getResponseModel().getMessage().getContent());
+            assertEquals(sb.toString().trim(), chatResult.getResponseModel().getMessage().getContent().trim());
         } catch (IOException | OllamaBaseException | InterruptedException e) {
             fail(e);
         }
@@ -246,12 +463,12 @@ class TestRealAPIs {
             OllamaChatRequestBuilder builder =
                     OllamaChatRequestBuilder.getInstance(config.getImageModel());
             OllamaChatRequest requestModel =
-                    builder.withMessage(OllamaChatMessageRole.USER, "What's in the picture?",
+                    builder.withMessage(OllamaChatMessageRole.USER, "What's in the picture?",Collections.emptyList(),
                             List.of(getImageFileFromClasspath("dog-on-a-boat.jpg"))).build();
 
             OllamaChatResult chatResult = ollamaAPI.chat(requestModel);
             assertNotNull(chatResult);
-            assertNotNull(chatResult.getResponse());
+            assertNotNull(chatResult.getResponseModel());
 
             builder.reset();
 
@@ -261,7 +478,7 @@ class TestRealAPIs {
 
             chatResult = ollamaAPI.chat(requestModel);
             assertNotNull(chatResult);
-            assertNotNull(chatResult.getResponse());
+            assertNotNull(chatResult.getResponseModel());
 
 
         } catch (IOException | OllamaBaseException | InterruptedException e) {
@@ -275,7 +492,7 @@ class TestRealAPIs {
         testEndpointReachability();
         try {
             OllamaChatRequestBuilder builder = OllamaChatRequestBuilder.getInstance(config.getImageModel());
-            OllamaChatRequest requestModel = builder.withMessage(OllamaChatMessageRole.USER, "What's in the picture?",
+            OllamaChatRequest requestModel = builder.withMessage(OllamaChatMessageRole.USER, "What's in the picture?",Collections.emptyList(),
                             "https://t3.ftcdn.net/jpg/02/96/63/80/360_F_296638053_0gUVA4WVBKceGsIr7LNqRWSnkusi07dq.jpg")
                     .build();
 
@@ -368,6 +585,14 @@ class TestRealAPIs {
     }
 }
 
+class DBQueryFunction implements ToolFunction {
+    @Override
+    public Object apply(Map<String, Object> arguments) {
+        // perform DB operations here
+        return String.format("Employee Details {ID: %s, Name: %s, Address: %s, Phone: %s}", UUID.randomUUID(), arguments.get("employee-name"), arguments.get("employee-address"), arguments.get("employee-phone"));
+    }
+}
+
 @Data
 class Config {
     private String ollamaURL;
@@ -392,4 +617,6 @@ class Config {
             throw new RuntimeException("Error loading properties", e);
         }
     }
+
+
 }

src/test/java/io/github/ollama4j/samples/AnnotatedTool.java

@@ -0,0 +1,21 @@
+package io.github.ollama4j.samples;
+
+import io.github.ollama4j.tools.annotations.ToolProperty;
+import io.github.ollama4j.tools.annotations.ToolSpec;
+
+import java.math.BigDecimal;
+
+public class AnnotatedTool {
+
+    @ToolSpec(desc = "Computes the most important constant all around the globe!")
+    public String computeImportantConstant(@ToolProperty(name = "noOfDigits",desc = "Number of digits that shall be returned") Integer noOfDigits ){
+        return BigDecimal.valueOf((long)(Math.random()*1000000L),noOfDigits).toString();
+    }
+
+    @ToolSpec(desc = "Says hello to a friend!")
+    public String sayHello(@ToolProperty(name = "name",desc = "Name of the friend") String name, Integer someRandomProperty, @ToolProperty(name="amountOfHearts",desc = "amount of heart emojis that should be used",  required = false) Integer amountOfHearts) {
+        String hearts = amountOfHearts!=null ? "♡".repeat(amountOfHearts) : "";
+        return "Hello " + name +" ("+someRandomProperty+") " + hearts;
+    }
+
+}

src/test/java/io/github/ollama4j/unittests/TestMockedAPIs.java

@@ -6,6 +6,7 @@ import io.github.ollama4j.exceptions.RoleNotFoundException;
 import io.github.ollama4j.models.chat.OllamaChatMessageRole;
 import io.github.ollama4j.models.embeddings.OllamaEmbedRequestModel;
 import io.github.ollama4j.models.embeddings.OllamaEmbedResponseModel;
+import io.github.ollama4j.models.request.CustomModelRequest;
 import io.github.ollama4j.models.response.ModelDetail;
 import io.github.ollama4j.models.response.OllamaAsyncResultStreamer;
 import io.github.ollama4j.models.response.OllamaResult;
@@ -52,12 +53,11 @@ class TestMockedAPIs {
     @Test
     void testCreateModel() {
         OllamaAPI ollamaAPI = Mockito.mock(OllamaAPI.class);
-        String model = OllamaModelType.LLAMA2;
-        String modelFilePath = "FROM llama2\nSYSTEM You are mario from Super Mario Bros.";
+        CustomModelRequest customModelRequest = CustomModelRequest.builder().model("mario").from("llama3.2:latest").system("You are Mario from Super Mario Bros.").build();
         try {
-            doNothing().when(ollamaAPI).createModelWithModelFileContents(model, modelFilePath);
-            ollamaAPI.createModelWithModelFileContents(model, modelFilePath);
-            verify(ollamaAPI, times(1)).createModelWithModelFileContents(model, modelFilePath);
+            doNothing().when(ollamaAPI).createModel(customModelRequest);
+            ollamaAPI.createModel(customModelRequest);
+            verify(ollamaAPI, times(1)).createModel(customModelRequest);
         } catch (IOException | OllamaBaseException | InterruptedException | URISyntaxException e) {
             throw new RuntimeException(e);
         }

src/test/java/io/github/ollama4j/unittests/jackson/TestChatRequestSerialization.java

@@ -4,6 +4,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
 
 import java.io.File;
+import java.util.Collections;
 import java.util.List;
 
 import io.github.ollama4j.models.chat.OllamaChatRequest;
@@ -42,7 +43,7 @@ public class TestChatRequestSerialization extends AbstractSerializationTest<Olla
 
     @Test
     public void testRequestWithMessageAndImage() {
-        OllamaChatRequest req = builder.withMessage(OllamaChatMessageRole.USER, "Some prompt",
+        OllamaChatRequest req = builder.withMessage(OllamaChatMessageRole.USER, "Some prompt", Collections.emptyList(),
                 List.of(new File("src/test/resources/dog-on-a-boat.jpg"))).build();
         String jsonRequest = serialize(req);
         assertEqualsAfterUnmarshalling(deserialize(jsonRequest, OllamaChatRequest.class), req);

src/test/java/io/github/ollama4j/unittests/jackson/TestEmbedRequestSerialization.java

@@ -1,36 +1,37 @@
 package io.github.ollama4j.unittests.jackson;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import io.github.ollama4j.models.embeddings.OllamaEmbedRequestBuilder;
+import io.github.ollama4j.models.embeddings.OllamaEmbedRequestModel;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import io.github.ollama4j.models.embeddings.OllamaEmbeddingsRequestModel;
-import io.github.ollama4j.models.embeddings.OllamaEmbeddingsRequestBuilder;
 import io.github.ollama4j.utils.OptionsBuilder;
 
-public class TestEmbeddingsRequestSerialization extends AbstractSerializationTest<OllamaEmbeddingsRequestModel> {
+public class TestEmbedRequestSerialization extends AbstractSerializationTest<OllamaEmbedRequestModel> {
 
-        private OllamaEmbeddingsRequestBuilder builder;
+        private OllamaEmbedRequestBuilder builder;
 
         @BeforeEach
         public void init() {
-            builder = OllamaEmbeddingsRequestBuilder.getInstance("DummyModel","DummyPrompt");
+            builder = OllamaEmbedRequestBuilder.getInstance("DummyModel","DummyPrompt");
         }
 
             @Test
     public void testRequestOnlyMandatoryFields() {
-        OllamaEmbeddingsRequestModel req = builder.build();
+        OllamaEmbedRequestModel req = builder.build();
         String jsonRequest = serialize(req);
-        assertEqualsAfterUnmarshalling(deserialize(jsonRequest,OllamaEmbeddingsRequestModel.class), req);
+        assertEqualsAfterUnmarshalling(deserialize(jsonRequest,OllamaEmbedRequestModel.class), req);
     }
 
         @Test
         public void testRequestWithOptions() {
             OptionsBuilder b = new OptionsBuilder();
-            OllamaEmbeddingsRequestModel req = builder
+            OllamaEmbedRequestModel req = builder
                     .withOptions(b.setMirostat(1).build()).build();
 
             String jsonRequest = serialize(req);
-            OllamaEmbeddingsRequestModel deserializeRequest = deserialize(jsonRequest,OllamaEmbeddingsRequestModel.class);
+            OllamaEmbedRequestModel deserializeRequest = deserialize(jsonRequest,OllamaEmbedRequestModel.class);
             assertEqualsAfterUnmarshalling(deserializeRequest, req);
             assertEquals(1, deserializeRequest.getOptions().get("mirostat"));
         }

src/test/resources/test-config.properties

@@ -1,4 +1,4 @@
 ollama.url=http://localhost:11434
-ollama.model=qwen:0.5b
-ollama.model.image=llava
+ollama.model=llama3.2:1b
+ollama.model.image=llava:latest
 ollama.request-timeout-seconds=120