{"id":15047369,"url":"https://github.com/jmont-dev/ollama-hpp","last_synced_at":"2025-04-06T17:11:23.575Z","repository":{"id":243875041,"uuid":"792981786","full_name":"jmont-dev/ollama-hpp","owner":"jmont-dev","description":"Modern, Header-only C++ bindings for the Ollama API.","archived":false,"fork":false,"pushed_at":"2025-03-29T22:34:13.000Z","size":3609,"stargazers_count":107,"open_issues_count":9,"forks_count":13,"subscribers_count":6,"default_branch":"master","last_synced_at":"2025-03-29T23:24:15.224Z","etag":null,"topics":["ai","cpp11","header-only","llama","llm","ollama","single-header"],"latest_commit_sha":null,"homepage":"","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/jmont-dev.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2024-04-28T05:04:44.000Z","updated_at":"2025-03-28T05:25:08.000Z","dependencies_parsed_at":null,"dependency_job_id":"1bd8d06a-1182-4c9a-b7e2-360f5b778a38","html_url":"https://github.com/jmont-dev/ollama-hpp","commit_stats":{"total_commits":153,"total_committers":1,"mean_commits":153.0,"dds":0.0,"last_synced_commit":"2eae9d8fd7852d76bc364f9570e9c05c727b8c32"},"previous_names":["jmont-dev/ollama-hpp"],"tags_count":5,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jmont-dev%2Follama-hpp","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jmont-dev%2Follama-hpp/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jmont-dev%2Follama-hpp/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jmont-dev%2Follama-hpp/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/jmont-dev","download_url":"https://codeload.github.com/jmont-dev/ollama-hpp/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":247517912,"owners_count":20951718,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["ai","cpp11","header-only","llama","llm","ollama","single-header"],"created_at":"2024-09-24T20:57:13.318Z","updated_at":"2025-04-06T17:11:23.561Z","avatar_url":"https://github.com/jmont-dev.png","language":"C++","funding_links":[],"categories":[],"sub_categories":[],"readme":"# ollama-hpp\nModern, Header-only C++11-20 bindings for the [Ollama](https://ollama.ai) API.\n\nAccess the full power of local language models in C++ with just a few lines of code:\n\n```C++\n#include \"ollama.hpp\"\n\nstd::cout \u003c\u003c ollama::generate(\"llama3:8b\", \"Why is the sky blue?\") \u003c\u003c std::endl;\n```\n\n## Quick Start\nDownload the header in singleheader/ollama.hpp and include it with your project to get started. No additional files or linking are required. C++11 is the minimum required language specification and C++14/17/20 are also supported.\n\nFor example:\n`g++ your_source_file.cpp -Iollama-hpp/singleheader -std=c++11`\n\nEnsure you have an active instance of the ollama server and any models you plan to run. For more details, see https://ollama.com. You can check if your ollama server is running using: `sudo systemctl status ollama`\n\n## Building examples\nTo build the ollama-hpp examples and test cases, use:\n`make -j8`\n\nTo run the examples and test cases, use:\n\n`build/test` \u003cbr\u003e\n`build/examples`\n\n## Full API\n\nThe test cases do a good job of providing discrete examples for each of the API features supported. I recommend reviewing these first in `test/test.cpp` to understand what the library and Ollama API provide.\n\n- [ollama-hpp](#ollama-hpp)\n  - [Quick Start](#quick-start)\n  - [Building examples](#building-examples)\n  - [Full API](#full-api)\n    - [Ollama Class and Singleton](#ollama-class-and-singleton)\n    - [Ollama Response](#ollama-response)\n    - [Set Server Parameters](#set-server-parameters)\n    - [Get Server Status](#get-server-status)\n    - [Get Server Version](#get-server-version)\n    - [Load a Model into Memory](#load-a-model-into-memory)\n    - [Pull, Copy, and Delete Models](#pull-copy-and-delete-models)\n    - [Retrieve Model Info](#retrieve-model-info)\n    - [List locally-available and running models](#list-locally-available-and-running-models)\n    - [Exception Handling](#exception-handling)\n    - [Basic Generation](#basic-generation)\n    - [Using Options](#using-options)\n    - [Streaming Generation](#streaming-generation)\n    - [Asynchronous Streaming Generation](#asynchronous-streaming-generation)\n    - [Using Images](#using-images)\n    - [Generation using Images](#generation-using-images)\n    - [Basic Chat Generation](#basic-chat-generation)\n    - [Chat with Multiple Messages](#chat-with-multiple-messages)\n    - [Streaming Chat Generation](#streaming-chat-generation)\n    - [Chat with Images](#chat-with-images)\n    - [Embedding Generation](#embedding-generation)\n    - [Debug Information](#debug-information)\n    - [Manual Requests](#manual-requests)\n    - [Handling Context](#handling-context)\n    - [Context Length](#context-length)\n  - [Single-header vs Separate Headers](#single-header-vs-separate-headers)\n  - [About this software](#about-this-software)\n  - [License](#license)\n\n\n### Ollama Class and Singleton\nThe `Ollama` class defines the logic required to interface with an ollama server.\n\n```C++\nOllama my_server(\"http://localhost:11434\");\nstd::cout \u003c\u003c my_server.generate(\"llama3:8b\", \"Why is the sky blue?\") \u003c\u003c std::endl;\n```\n\nFor convenience, a static singleton of the Ollama class is included in the `ollama` namespace which defaults to http://localhost:11434. Using the static singleton is preferred and will be easiest for most people. This allows you to make calls to a default server immediately simply by including the header. All calls to the Ollama class are also valid for the singleton:\n\n```C++\n// No object creation required; the static singleton is usable as soon as the file is included\n// http://localhost:11434 is the default server location\nollama::generate(\"llama3:8b\", \"Why is the sky blue?\") \u003c\u003c std::endl;\n```\n\n### Ollama Response\nThe `ollama::response` class contains a response from the server. This is the default class returned for most generations. It can be flexibly represented as `nlohmann::json` or a `std::string` depending on context.\n\n```C++\nollama::response response = ollama::generate(\"llama3:8b\", \"Why is the sky blue?\");\n\n// A JSON object created from the server response\nnlohmann::json data = response.as_json();\n\n// A string representing the JSON data received\nstd::string json_string = response.as_json_string();\n\n// Usually contains just the human-readable response from the generation/chat\nstd::string simple_string = response.as_simple_string();\n```\n\nWhen interacting with streams or strings, `ollama::response` will default to using the `as_simple_string` representation. This usually contains the human-readable portion of the response.\n\n```C++\n// Will print the generated human-readable portion of response, not the JSON\nstd::cout \u003c\u003c response \u003c\u003c std::endl;\n```\n\n### Set Server Parameters\nThe `Ollama` object contains a series of intelligent defaults used to communicate with an ollama server. You will not typically have to change these, but can do so if required:\n\n```C++\n// Optional. By default, the server URL is set to http://localhost:11434. \n// Use this function if your server resides at a different URL.\nollama::setServerURL(\"http://localhost:11434\");    \n\n// Optional. Set the read and write timeouts in seconds for server interactions.\n// If you have a large model with a long response time you may need to increase these.\nollama::setReadTimeout(120);\nollama::setWriteTimeout(120);\n```\n\n### Get Server Status\nVerify that the Ollama server is running with `ollama::is_running()`\n\n```C++\nbool running = ollama::is_running();\n```\n\n### Get Server Version\nReturn a `std::string` containing the version of the ollama server using `ollama::get_version()`\n\n```C++\nstd::string version = ollama::get_version();\n```\n\n### Load a Model into Memory\nThis can optionally be used to deliberately load a model into memory prior to use. This occurs automatically when a request is made for an unloaded model, but can be useful for loading a model in advance.\n\n```C++\nbool model_loaded = ollama::load_model(\"llama3:8b\");\n```\n\n### Pull, Copy, and Delete Models\nYou can easily pull, copy, and delete models locally available within your ollama server. For the full list of models available in the Ollama library, see https://ollama.com/library.\n\n```C++\n// Pull a model by specifying a model name.\nbool model_pulled = ollama::pull_model(\"llama3:8b\");\n\n// Copy a model by specifying a source model and destination model name.\nbool model_copied = ollama::copy_model(\"llama3:8b\", \"llama3_copy\");\n\n// Delete a model by specifying a model name.\nbool model_deleted = ollama::delete_model(\"llama3_copy\");\n```\n\n### Retrieve Model Info\nModel information can be pulled for a specified model name. This is returned as an `nlohmann::json` object.\n\n```C++\n// Request model info from the Ollama server.\nnlohmann::json model_info = ollama::show_model_info(\"llama3:8b\");\nstd::cout \u003c\u003c \"Model family is \" \u003c\u003c model_info[\"details\"][\"family\"] \u003c\u003c std::endl;\n```\n\n### List locally-available and running models\nYou can query a list of locally-available models on your ollama server using the following. This is returned as a `std::vector` of `std::string`.\n\n```C++\n// List the models available locally in the ollama server\nstd::vector\u003cstd::string\u003e models = ollama::list_models();\n```\n\nYou can similarly query a list of currently-running models on your ollama server using:\n\n```C++\n// List the models available locally in the ollama server\nstd::vector\u003cstd::string\u003e models = ollama::list_running_models();\n```\n\nFor detailed parameters for these models, you can obtain the verbose JSON model descriptions using `ollama::list_model_json()` and `ollama::running_model_json()`.\n\n### Exception Handling\nMost calls will throw `ollama::exception` in the event of an error, with details on the exception that has occurred. Exceptions are enabled by default.\n\n```C++\ntry { \n    ollama::generate(\"Non-existent-model\", \"Requesting this model will throw an error\"); \n} \ncatch(ollama::exception\u0026 e) { std::cout \u003c\u003c e.what() \u003c\u003c std::endl; }\n```\n\nYou can also dynamically enable and disable exceptions. If exceptions are disabled, functions will return an empty `ollama::response` or false where appropriate instead of throwing `ollama::exception`.\n\n```C++ \nollama::allow_exceptions(false);\n```\n\n### Basic Generation\nA generation call can be made by specifying a model name and prompt. This will return an `ollama::response`.\n\n```C++\nollama::response response = ollama::generate(\"llama3:8b\", \"Why is the sky blue?\");\n\nstd::cout \u003c\u003c response \u003c\u003c std::endl;\n```\n\nAs mentioned previously, you can access `ollama::response` as an `nlohmann::json` object or `std::string` depending on your preference.\n\nThe default call does not use streaming from the Ollama server, so the reply will block and be received as one response.\n\n### Using Options\nAll generative calls can include options specified through an `ollama::options` object. This class extends `nlohmann::json` and can support the options specified [here](https://github.com/ollama/ollama/blob/main/docs/api.md#generate-request-with-options).\n\n```C++\nollama::options options;\n\n// Access and set these options like any other json type.\noptions[\"seed\"] = 1;\noptions[\"temperature\"] = 0;\noptions[\"num_predict\"] = 18;\n\n// Options can be included with any generative function\nollama::response response = ollama::generate(\"llama3:8b\", \"Why is the sky blue?\", options);\n```\n\n### Streaming Generation\nYou can use a streaming generation to bind a callback function that is invoked every time a token is received. This is useful when you have larger responses and want to show tokens as they arrive.\n\n```C++\n\nbool on_receive_response(const ollama::response\u0026 response)\n{   \n    // Print the token received\n    std::cout \u003c\u003c response \u003c\u003c std::flush;\n\n    // The server will set \"done\" to true for the last response\n    if (response.as_json()[\"done\"]==true) std::cout \u003c\u003c std::endl;\n\n    // Return true to continue streaming this response; return false to stop immediately.\n    return true;\n}\n\n// This function will be called every token\nstd::function\u003cbool(const ollama::response\u0026)\u003e response_callback = on_receive_response;  \n\n// Bind the callback to the generation\nollama::generate(\"llama3:8b\", \"Why is the sky blue?\", response_callback);\n```\nThis function uses a blocking socket call so it will still block the primary thread until all tokens are received.\n\n### Asynchronous Streaming Generation\nYou can launch a streaming call in a thread if you don't want it to block the primary thread. This will allow asynchronous execution.\n\n```C++\n\nstd::atomic\u003cbool\u003e done{false};\n\nbool on_receive_response(const ollama::response\u0026 response)\n{   \n    std::cout \u003c\u003c response \u003c\u003c std::flush;\n\n    if (response.as_json()[\"done\"]==true) { done=true;  std::cout \u003c\u003c std::endl;}\n\n    // Return true to continue streaming this response; return false to stop immediately.\n    return !done;\n}\n\n// Use std::function to define a callback from an existing function\n// You can also use a lambda with an equivalent signature\nstd::function\u003cbool(const ollama::response\u0026)\u003e response_callback = on_receive_response;  \n\n// You can launch the generation in a thread with a callback to use it asynchronously.\nstd::thread new_thread( [response_callback]{ \n  ollama::generate(\"llama3:8b\", \"Why is the sky blue?\", response_callback); } );\n\n// Prevent the main thread from exiting while we wait for an asynchronous response.\nwhile (!done) { std::this_thread::sleep_for(std::chrono::microseconds(100) ); }\nnew_thread.join();\n```\nThe return value of the function determines whether to continue streaming or stop. This is useful in cases where you want to stop immediately instead of waiting for an entire response to return.\n\n### Using Images\nGenerations can include images for vision-enabled models such as `llava`. The `ollama::image` class can load an image from a file and encode it as a [base64](https://en.wikipedia.org/wiki/Base64) string.\n\n```C++\nollama::image image = ollama::image::from_file(\"llama.jpg\");\n```\n\nImages can also be represented as a base64 string literal.\n\n```C++\nollama::image base64_image = ollama::image::from_base64_string(\"iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAFUlEQVR42mNkYPhfz0AEYBxVSF+FAP5FDvcfRYWgAAAAAElFTkSuQmCC\");\n```\n\n### Generation using Images\nGenerative calls can also include images. \n\n```C++\nollama::image image = ollama::image::from_file(\"llama.jpg\");\n\nollama::response response = \n  ollama::generate(\"llava\", \"What do you see in this image?\", options, image);\n```\n\nMultiple images can be included using the `ollama::images` container.\n\n```C++\nollama::image image = ollama::image::from_file(\"llama.jpg\");\nollama::image image2 = ollama::image::from_file(\"another_llama.jpg\");\n\n// Include a list of images here\nollama::images images={image, image2};\n\nollama::response response = \n  ollama::generate(\"llava\", \"What do you see in these images?\", options, images);\n```\n\n### Basic Chat Generation\nThe Ollama chat API can be used as an alternative to basic generation. This allows the user to send a series of messages to the server and obtain the next response in the conversation.\n\n`ollama::message` represents a single chat message in the conversation. It is composed of a role, content, and an optional series of images.\n\n```C++\nollama::message message(\"user\", \"Why is the sky blue?\");\n```\n\nSending a message to the server will return the next message in the conversation.\n```C++\nollama::message message(\"user\", \"Why is the sky blue?\");\n\nollama::response response = ollama::chat(\"llama3:8b\", message);\n```\n\nLike any generative call, chat calls can also include options.\n\n```C++\nollama::options options;\noptions[\"seed\"] = 1;\n\nollama::message message(\"user\", \"Why is the sky blue?\");\n\nollama::response response = ollama::chat(\"llama3:8b\", message, options);\n```\n\n### Chat with Multiple Messages\n\nYou can use a collection of messages in a chat. This allows chain-of-thought prompting and can be useful for setting up a conversation.\n\n```C++\nollama::message message1(\"user\", \"What are nimbus clouds?\");\nollama::message message2(\"assistant\", \"Nimbus clouds are dark rain clouds.\");\nollama::message message3(\"user\", \"What are some other kinds of clouds?\");\n\nollama::messages messages = {message1, message2, message3};\n\nollama::response response = ollama::chat(\"llama3:8b\", messages);\n```\n\n### Streaming Chat Generation\nThe default chat generation does not stream tokens and will return the entire reply as one response. You can bind a callback function to handle a streamed response for each token, just like a standard generation.\n\n```C++\n\nbool on_receive_response(const ollama::response\u0026 response)\n{   \n  std::cout \u003c\u003c response \u003c\u003c std::flush;\n\n  if (response.as_json()[\"done\"]==true) std::cout \u003c\u003c std::endl;\n\n  // Return true to continue streaming, or false to stop immediately\n  return true;\n}\n\nstd::function\u003cbool(const ollama::response\u0026)\u003e response_callback = on_receive_response;  \n\nollama::message message(\"user\", \"Why is the sky blue?\");       \n\nollama::chat(\"llama3:8b\", message, response_callback, options);\n```\n\n### Chat with Images\nThe `ollama::message` class can contain an arbitrary number of `ollama::image` objects to be sent to the server. This allows images to be sent in each message of a chat for vision-enabled models. \n\n```C++\nollama::image image = ollama::image::from_file(\"llama.jpg\");\n\n// We can optionally include images with each message. \n//Vision-enabled models will be able to utilize these.\nollama::message message_with_image(\"user\", \"What do you see in this image?\", image);\nollama::response response = ollama::chat(\"llava\", message_with_image);\n```\n### Embedding Generation\nEmbeddings can be generated from a specified model name and prompt.\n\n```C++\nollama::response response = ollama::generate_embeddings(\"llama3:8b\", \"Why is the sky blue?\");\n```\n\nLike any other generative function, options can be included during generation.\n\n```C++\nollama::options options;\noptions[\"num_predict\"] = 20;\n\nollama::response response = \n  ollama::generate_embeddings(\"llama3:8b\", \"Why is the sky blue?\", options);\n```\n\n### Debug Information\nDebug logging for requests and replies to the server can easily be turned on and off. This is useful if you want to see the actual JSON sent and received from the server.\n\n```C++\nollama::show_requests(true);\nollama::show_replies(true);\n```\n\n### Manual Requests\nFor those looking for greater control of the requests sent to the ollama server, manual requests can be created through the `ollama::request` class. This class extends `nlohmann::json` and can be treated as a standard JSON object.\n\n```C++\nollama::request request(ollama::message_type::generation);\nrequest[\"model\"]=\"mistral\";\nrequest[\"prompt\"]=\"Why is the sky blue?\";\nrequest[\"system\"] = \"Talk like a pirate for the next reply.\"\nstd::cout \u003c\u003c ollama::generate(request) \u003c\u003c std::endl;\n```\nThis provides the most customization of the request. Users should take care to ensure that valid fields are provided, otherwise an exception will likely be thrown on response. Manual requests can be made for generate, chat, and embedding endpoints.\n\n### Handling Context\nContext from previous generate requests can be used by including a past `ollama::response` with `generate`:\n\n**Note:** The Context parameter has been [deprecated](https://github.com/ollama/ollama/pull/7878) in newer versions of Ollama. It is recommended to use the `chat` endpoint for maintaining context over time.\n```C++\nstd::string model = \"llama3.1:8b\";\nollama::response context = ollama::generate(model, \"Why is the sky blue?\");\nollama::response response = ollama::generate(model, \"Tell me more about this.\", context);\n```\n\nThis will provide the past user prompt and response to the model when making a new generation. Context can be chained over multiple messages and will contain the entire conversation history from the first prompt:\n\n```C++\nollama::response first_response = ollama::generate(model, \"Why is the sky blue?\");\nollama::response second_response = ollama::generate(model, \"Tell me more about this.\", first_response);\nollama::response third_response = ollama::generate(model, \"What was the first question that I asked you?\", second_response);\n```\n\nContext can also be added as JSON when creating manual requests:\n```C++\nollama::response response = ollama::generate(\"llama3.1:8b\", \"Why is the sky blue?\");\n\nollama::request request(ollama::message_type::generation);\nrequest[\"model\"]=\"llama3.1:8b\";\nrequest[\"prompt\"]=\"Why is the sky blue?\";\nrequest[\"context\"] = response.as_json()[\"context\"];\nstd::cout \u003c\u003c ollama::generate(request) \u003c\u003c std::endl;\n```\n\nNote that the `chat` endpoint has no specialized context parameter; context is simply supplied through the message history of the conversation:\n\n```C++\nollama::message message1(\"user\", \"What are nimbus clouds?\");\nollama::message message2(\"assistant\", \"Nimbus clouds are dense, moisture-filled clouds that produce rain.\");\nollama::message message3(\"user\", \"What was the first question I asked you?\");\n\nollama::messages messages = {message1, message2, message3};\n\nstd::cout \u003c\u003c ollama::chat(\"llama3.1:8b\", messages) \u003c\u003c std::endl;\n```\n### Context Length\nMost language models have a maximum input context length that they can accept. This length determines the number of previous tokens that can be provided along with the prompt as an input to the model before information is lost. Llama 3.1, for example, has a maximum context length of 128k tokens; a much smaller number of \u003cb\u003e2048\u003c/b\u003e tokens is often enabled by default from Ollama in order to reduce memory usage. You can increase the size of the context window using the `num_ctx` parameter in `ollama::options` for tasks where you need to retain a long conversation history:\n\n```C++\n// Set the size of the context window to 8192 tokens.\nollama::options options;\noptions[\"num_ctx\"] = 8192; \n\n// Perform a simple generation which includes model options.\nstd::cout \u003c\u003c ollama::generate(\"llama3.1:8b\", \"Why is the sky blue?\", options) \u003c\u003c std::endl;\n```\n\nKeep in mind that increasing context length will increase the model size in memory when loading to a GPU. You should ensure your hardware has sufficient memory to hold the larger model when configuring for long-context tasks.\n\n## Single-header vs Separate Headers\nFor convenience, ollama-hpp includes a single-header version of the library in `singleheader/ollama.hpp` which bundles the core ollama.hpp code with single-header versions of nlohmann json, httplib, and base64.h. Each of these libraries is available under the MIT license and their respective licenses are included.\nThe single-header include can be regenerated from these standalone files by running `./make_single_header.sh`\n\nIf you prefer to include the headers for these libraries separately, you can do so by including the standard header located in `include/ollama.hpp`. \n\n## About this software\n\nOllama is a high-quality REST server and API providing an interface to run language models locally via llama.cpp.\n\nOllama was made by Jeffrey Morgan (@jmorganca) and the Ollama team and is available under the MIT License. To support this project or for more details go to https://github.com/ollama or https://ollama.ai \n\nThis library is a header-only C++ integration of the Ollama API providing access to most API features while integrating them with std library classes or popular header-only libraries within the community. The following external libraries are used:\n\n* **nlohmnann JSON** is a feature-rich header-only C++ JSON implementation. This library was created by Niels Lohmann and is available under the MIT License. For more details visit: https://github.com/nlohmann/json\n\n* **httplib** is a header-only C++ http/https library. This library was created by Yuji Hirose and is available under the MIT License. For more details visit: https://github.com/yhirose/cpp-httplib\n\n* **Base64.h** is a header-only C++ library for encoding and decoding Base64 values. This library was created by tomykaira and is available under the MIT License. For more details visit: https://gist.github.com/tomykaira/f0fd86b6c73063283afe550bc5d77594\n\n## License\nMIT License\n\nCopyright (c) 2025 James Montgomery (jmont)\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fjmont-dev%2Follama-hpp","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fjmont-dev%2Follama-hpp","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fjmont-dev%2Follama-hpp/lists"}