{"id":1109,"date":"2026-06-15T18:14:28","date_gmt":"2026-06-15T18:14:28","guid":{"rendered":"https:\/\/convly.ai\/ollama-vs-jan-2026\/"},"modified":"2026-06-15T18:17:42","modified_gmt":"2026-06-15T18:17:42","slug":"ollama-vs-jan-2026","status":"publish","type":"post","link":"https:\/\/convly.ai\/fr\/ollama-vs-jan-2026\/","title":{"rendered":"Ollama vs Jan: Which Local AI App Wins in 2026?"},"content":{"rendered":"<p>People keep framing this as a duel, but Ollama and Jan were built to answer different questions. Ollama is a runtime: a command-line tool and HTTP server that hosts models and exposes an API. Jan is a finished desktop app: an open-source, ChatGPT-style chat client you fully own. Ask &#8220;how do I serve a model to my code?&#8221; and the answer is Ollama. Ask &#8220;how do I chat with a private model without a terminal?&#8221; and the answer is Jan.<\/p>\n<p>That distinction used to be clean. In 2026 it&#8217;s blurrier \u2014 Ollama shipped a native desktop GUI, and Jan added a real developer API server and Model Context Protocol (MCP) tools. The lines now overlap enough that picking the wrong one wastes a weekend. This piece compares both on UX, model libraries, raw speed, privacy, API modes, extensibility and OS support, using current versions and real numbers, then tells you plainly who should run which.<\/p>\n<div class=\"convly-tldr\">\n<h3>Principaux enseignements<\/h3>\n<ul>\n<li><strong>Different tools, not rivals.<\/strong> Ollama (v0.30.8, June 2026) is a headless runtime + API; Jan (v0.8.2, June 2026) is a GUI chat app. Many people run both \u2014 Ollama as backend, a GUI on top.<\/li>\n<li><strong>Ollama owns the developer workflow.<\/strong> One install, an OpenAI-compatible endpoint on port 11434, headless server use, and the widest tooling\/agent integration. It&#8217;s the engineering default.<\/li>\n<li><strong>Jan owns the desktop experience.<\/strong> A polished UI, conversation history, an extension system and \u2014 uniquely here \u2014 built-in MCP tool support with inline approval and citation cards.<\/li>\n<li><strong>Speed is basically a tie.<\/strong> Both lean on llama.cpp, so tokens-per-second on the same GGUF are within a few percent. Both now offer MLX on Apple Silicon for a sizeable boost over the Metal path.<\/li>\n<li><strong>Licensing matters for business.<\/strong> Ollama is MIT, Jan is Apache 2.0 \u2014 both permissive and commercial-friendly, unlike some copyleft alternatives.<\/li>\n<li><strong>OS gotcha:<\/strong> Jan ships a GUI on all three desktops; Ollama&#8217;s native GUI is Mac\/Windows only, Linux stays CLI.<\/li>\n<\/ul>\n<\/div>\n<div id=\"ez-toc-container\" class=\"ez-toc-v2_0_84 counter-flat ez-toc-counter ez-toc-container-direction\">\n<label for=\"ez-toc-cssicon-toggle-item-6a3077940020a\" class=\"ez-toc-cssicon-toggle-label\"><span class=\"\"><span class=\"eztoc-hide\" style=\"display:none;\">Toggle<\/span><span class=\"ez-toc-icon-toggle-span\"><svg style=\"fill: #000000;color:#000000\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\" class=\"list-377408\" width=\"20px\" height=\"20px\" viewbox=\"0 0 24 24\" fill=\"none\"><path d=\"M6 6H4v2h2V6zm14 0H8v2h12V6zM4 11h2v2H4v-2zm16 0H8v2h12v-2zM4 16h2v2H4v-2zm16 0H8v2h12v-2z\" fill=\"currentColor\"><\/path><\/svg><svg style=\"fill: #000000;color:#000000\" class=\"arrow-unsorted-368013\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"10px\" height=\"10px\" viewbox=\"0 0 24 24\" version=\"1.2\" baseprofile=\"tiny\"><path d=\"M18.2 9.3l-6.2-6.3-6.2 6.3c-.2.2-.3.4-.3.7s.1.5.3.7c.2.2.4.3.7.3h11c.3 0 .5-.1.7-.3.2-.2.3-.5.3-.7s-.1-.5-.3-.7zM5.8 14.7l6.2 6.3 6.2-6.3c.2-.2.3-.5.3-.7s-.1-.5-.3-.7c-.2-.2-.4-.3-.7-.3h-11c-.3 0-.5.1-.7.3-.2.2-.3.5-.3.7s.1.5.3.7z\"\/><\/svg><\/span><\/span><\/label><input type=\"checkbox\"  id=\"ez-toc-cssicon-toggle-item-6a3077940020a\"  aria-label=\"Toggle\" \/><nav><ul class='ez-toc-list ez-toc-list-level-1' ><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-1\" href=\"https:\/\/convly.ai\/fr\/ollama-vs-jan-2026\/#The_core_difference_runtime_vs_app\" >The core difference: runtime vs. app<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-2\" href=\"https:\/\/convly.ai\/fr\/ollama-vs-jan-2026\/#Versions_and_whats_current_mid-2026\" >Versions and what&#8217;s current (mid-2026)<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-3\" href=\"https:\/\/convly.ai\/fr\/ollama-vs-jan-2026\/#UX_CLI_muscle_vs_GUI_polish\" >UX: CLI muscle vs. GUI polish<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-4\" href=\"https:\/\/convly.ai\/fr\/ollama-vs-jan-2026\/#Models_performance_and_the_llamacpp_truth\" >Models, performance and the llama.cpp truth<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-5\" href=\"https:\/\/convly.ai\/fr\/ollama-vs-jan-2026\/#API_server_mode_and_extensibility\" >API, server mode and extensibility<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-6\" href=\"https:\/\/convly.ai\/fr\/ollama-vs-jan-2026\/#OS_support_and_privacy\" >OS support and privacy<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-7\" href=\"https:\/\/convly.ai\/fr\/ollama-vs-jan-2026\/#FAQ\" >FAQ<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-8\" href=\"https:\/\/convly.ai\/fr\/ollama-vs-jan-2026\/#Bottom_line\" >R\u00e9sultat<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-9\" href=\"https:\/\/convly.ai\/fr\/ollama-vs-jan-2026\/#Related_articles\" >Articles connexes<\/a><\/li><\/ul><\/nav><\/div>\n<h2><span class=\"ez-toc-section\" id=\"The_core_difference_runtime_vs_app\"><\/span>The core difference: runtime vs. app<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>The cleanest way to think about it: Ollama is plumbing, Jan is a faucet.<\/p>\n<p>Ollama installs a background service (<code>ollama serve<\/code>) that pulls models, runs inference, and answers HTTP requests on port 11434. Out of the box it has no chat window \u2014 its job is to host models so <em>other things<\/em> can talk to them: your Python script, a coding agent, Open WebUI, or Jan itself. If you want LLMs inside apps and automation, this is the layer you wire in. Our <a href=\"\/fr\/what-is-ollama-complete-guide-2026\/\">complete guide to what Ollama is<\/a> goes deeper on the runtime model.<\/p>\n<p>Jan flips that. It&#8217;s a desktop application you download, open, and use \u2014 model browser, chat threads, assistants, settings panels, the lot. It bundles its own llama.cpp engine, so it doesn&#8217;t <em>besoin<\/em> Ollama, but it can also connect to one (or to OpenAI, Anthropic and Groq) as a backend. Jan is what a non-technical user actually sees and clicks.<\/p>\n<p>The practical upshot, and the reason &#8220;versus&#8221; undersells it: a very common 2026 setup is Ollama running headless on a workstation or VPS, with Jan or a similar client as the front end. They cooperate happily.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Versions_and_whats_current_mid-2026\"><\/span>Versions and what&#8217;s current (mid-2026)<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>Both projects move fast, so pin the facts. Ollama&#8217;s latest release is <strong>v0.30.8<\/strong>, dated June 12, 2026, with recent work on prompt caching (decoupled from context shift for better KV-cache reuse), more stable MLX inference, and tighter coding-agent integrations \u2014 its <code>ollama launch<\/code> command can stand up Claude Code, Claude Desktop, Codex, Copilot and more against a local model with one line. Jan&#8217;s latest is <strong>v0.8.2<\/strong>, released June 1, 2026, which added AMD ROCm\/HIP support on Linux, pause\/resume model downloads, and a safer default context size (<code>ctx-size<\/code> defaults to 8192 rather than the model&#8217;s full trained context) \u2014 on top of the v0.8.0 inline-MCP overhaul and v0.8.1 Anthropic-compatible providers.<\/p>\n<p>By adoption, Jan reports roughly 5.3 million downloads and 41,000+ GitHub stars. Ollama doesn&#8217;t publish a clean download figure but is the de facto runtime across local-AI tooling and dominates GitHub mindshare in the category.<\/p>\n<table class=\"convly-vs\">\n<thead>\n<tr>\n<th>Spec<\/th>\n<th>Ollama<\/th>\n<th>Jan<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Latest version (mid-2026)<\/td>\n<td>v0.30.8 (Jun 12, 2026)<\/td>\n<td>v0.8.2 (Jun 1, 2026)<\/td>\n<\/tr>\n<tr>\n<td>Type<\/td>\n<td>CLI + HTTP server (runtime)<\/td>\n<td>Desktop GUI app<\/td>\n<\/tr>\n<tr>\n<td>Native GUI<\/td>\n<td>macOS 12+ &#038; Windows (since v0.10.0)<\/td>\n<td>macOS, Windows, Linux<\/td>\n<\/tr>\n<tr>\n<td>Headless server<\/td>\n<td>Yes (Linux\/server-friendly)<\/td>\n<td>No \u2014 needs a display<\/td>\n<\/tr>\n<tr>\n<td>API server<\/td>\n<td>Port 11434, OpenAI-compatible \/v1<\/td>\n<td>Port 1337, OpenAI-compatible \/v1<\/td>\n<\/tr>\n<tr>\n<td>Inference backend<\/td>\n<td>llama.cpp (+ MLX on Apple Silicon)<\/td>\n<td>llama.cpp (+ MLX, + ROCm on Linux)<\/td>\n<\/tr>\n<tr>\n<td>Model source<\/td>\n<td>Curated Ollama registry (+ GGUF import)<\/td>\n<td>Jan Hub + Hugging Face GGUF<\/td>\n<\/tr>\n<tr>\n<td>MCP tool support<\/td>\n<td>Not native<\/td>\n<td>Yes (inline approval, citations)<\/td>\n<\/tr>\n<tr>\n<td>Remote providers<\/td>\n<td>Own cloud models<\/td>\n<td>OpenAI, Anthropic, Groq, Google, + custom (incl. Ollama)<\/td>\n<\/tr>\n<tr>\n<td>Licence<\/td>\n<td>MIT (Ollama Inc.)<\/td>\n<td>Apache 2.0 (Menlo Research)<\/td>\n<\/tr>\n<tr>\n<td>Min RAM (GUI)<\/td>\n<td>~8 GB<\/td>\n<td>~8 GB<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2><span class=\"ez-toc-section\" id=\"UX_CLI_muscle_vs_GUI_polish\"><\/span>UX: CLI muscle vs. GUI polish<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>This is where the old &#8220;CLI vs GUI&#8221; clich\u00e9 needs updating. Ollama did ship a native desktop app in v0.10.0 (July 2025) \u2014 chat window, model dropdown, streaming, and drag-and-drop for text, Markdown, PDFs and code. It&#8217;s genuinely usable for newcomers on Mac and Windows. But it&#8217;s a thin layer over the engine; the CLI is still where Ollama&#8217;s power lives, and Linux users get no native GUI at all.<\/p>\n<p>Jan was a GUI from day one and it shows. The chat interface (reworked again in v0.7.6, January 2026) feels like a product, not a wrapper: persistent threads, an assistants framework, a model hub with hardware-aware recommendations, file attachments, and a settings surface that exposes llama.cpp knobs without dropping you to a shell. For someone who just wants a private ChatGPT on their laptop, Jan asks for less.<\/p>\n<p>Where Ollama pulls ahead is anything programmatic. <code>ollama pull llama3.3<\/code> et <code>ollama run<\/code> are muscle memory for engineers, Modelfiles let you bake system prompts and parameters into reusable images, and the whole thing scripts cleanly. If you&#8217;re new to the runtime side, <a href=\"\/fr\/how-to-install-ollama-2026\/\">our install walkthrough<\/a> gets you to a working endpoint in minutes.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Models_performance_and_the_llamacpp_truth\"><\/span>Models, performance and the llama.cpp truth<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>Here&#8217;s the fact that deflates a lot of benchmark arguments: <strong>both tools call llama.cpp under the hood.<\/strong> For a given model and quantization, raw inference speed is roughly the same. Independent tests put llama.cpp itself about 3\u201310% faster than Ollama on NVIDIA GPUs (overhead from Ollama&#8217;s Go server layer), and on an M3 Pro you&#8217;ll see something like 45\u201360 tokens\/sec on an 8B model in either app, depending on quantization and GPU core count.<\/p>\n<p>The real performance lever in 2026 is the <em>backend<\/em>, and both have closed the gap. On Apple Silicon, MLX runs meaningfully faster than the Metal\/llama.cpp path \u2014 roughly 1.4\u20131.8\u00d7 (about 40\u201380%) on mid-size 7B\u201313B dense models, and more on Mixture-of-Experts models and the newest M5-class chips. Jan added native MLX in v0.7.7, while Ollama shipped MLX in preview (March 2026) and has been hardening it across the v0.30.x line. Jan also shipped AMD ROCm support on Linux in v0.8.2, which matters if you&#8217;re on Radeon. For squeezing absolute maximum throughput you&#8217;d still reach for raw llama.cpp or vLLM, a tradeoff we break down in our <a href=\"\/fr\/ollama-vs-lm-studio-vs-vllm-vs-llama-cpp-2026\/\">Ollama vs LM Studio vs vLLM vs llama.cpp comparison<\/a>.<\/p>\n<p>On the library, the philosophies differ. Ollama curates a registry with clean shorthand names (<code>gemma3:12b<\/code>, <code>qwen3:8b<\/code>) \u2014 fast and foolproof for the popular models, with hundreds of curated entries and thousands of total variants. Jan leans on Jan Hub plus direct Hugging Face GGUF access, which is friendlier for hunting niche fine-tunes and community quants. Either way, if you&#8217;re choosing <em>ce que<\/em> to run, our roundup of the <a href=\"\/fr\/best-local-llms-to-run-on-ollama-2026\/\">best local LLMs for Ollama<\/a> applies to both.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"API_server_mode_and_extensibility\"><\/span>API, server mode and extensibility<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>Both expose an OpenAI-compatible REST API, so drop-in use with Continue, Cursor or your own code is trivial \u2014 you just point the base URL at port 11434 (Ollama) or 1337 (Jan) with the <code>\/v1<\/code> suffix. Ollama additionally implements an Anthropic-compatible messages API, which is what lets <code>ollama launch<\/code> point Claude Code and similar agents straight at a local model. The difference is posture. Ollama is designed to run always-on and headless, which makes it the natural choice for a server, a CI box, or an agent backend. Jan&#8217;s server is a toggle inside a desktop app; great for local dev, awkward as a permanent unattended service because it expects a display.<\/p>\n<p>Extensibility is Jan&#8217;s standout. Its extension system lets developers add model providers, remote APIs, tools and UI tweaks \u2014 and on top of that, Jan has real <strong>Support MCP<\/strong>: MCP came out of experimental back in 2025, and v0.8.0 (May 2026) added inline tool approval with citation cards, with the approval panel showing the exact arguments inside the tool card before you accept or deny; v0.8.1 then added Anthropic-compatible custom providers. That&#8217;s the single biggest feature gap in this comparison; Ollama doesn&#8217;t do MCP natively. Ollama&#8217;s extensibility instead flows through its ecosystem \u2014 Modelfiles, the registry, and a deep bench of coding-agent integrations (Claude Code, Codex, Copilot, Cline, OpenCode) that you trigger from the runtime.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"OS_support_and_privacy\"><\/span>OS support and privacy<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>Privacy is a wash, and it&#8217;s the good kind of wash: both are local-first and run fully offline once models are downloaded. Neither phones home for inference. Jan is explicit that it only contacts remote APIs you deliberately configure; Ollama&#8217;s local models never leave the box (its optional hosted cloud models are a separate, opt-in feature). For regulated or air-gapped environments, either works \u2014 and the permissive MIT\/Apache 2.0 licenses keep legal off your back.<\/p>\n<p>OS coverage is where to read the fine print. Both run on macOS, Windows and Linux. But Jan delivers a graphical app on all three, while Ollama&#8217;s native GUI is Mac\/Windows only \u2014 Linux remains CLI (or a third-party front end). If your daily driver is desktop Linux and you want a window to click, that nudges you toward Jan, or toward Ollama-plus-a-web-UI.<\/p>\n<div class=\"convly-procons\">\n<div class=\"pros\">\n<h4>Pick Ollama if\u2026<\/h4>\n<ul>\n<li>You&#8217;re a developer wiring LLMs into scripts, apps or agents via API.<\/li>\n<li>You need a headless, always-on server (workstation, VPS, CI).<\/li>\n<li>You want the broadest coding-agent and tooling integrations.<\/li>\n<li>You live in the terminal and want Modelfiles and clean versioned model names.<\/li>\n<\/ul>\n<\/div>\n<div class=\"cons\">\n<h4>Pick Jan if\u2026<\/h4>\n<ul>\n<li>You want a polished, own-it-yourself ChatGPT-style desktop app.<\/li>\n<li>You need MCP tools wired to local models, out of the box.<\/li>\n<li>You&#8217;re on desktop Linux and want a real GUI.<\/li>\n<li>You&#8217;re non-technical, or buying for a team that won&#8217;t touch a CLI.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<h2><span class=\"ez-toc-section\" id=\"FAQ\"><\/span>FAQ<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<h3>Is Jan built on top of Ollama?<\/h3>\n<p>No. Jan ships its own bundled llama.cpp engine and runs models independently. It <em>can<\/em> connect to an Ollama server as one of several backends, but it doesn&#8217;t require Ollama to function. Out of the box, Jan handles downloading and inference on its own.<\/p>\n<h3>Can I use Ollama and Jan together?<\/h3>\n<p>Yes, and it&#8217;s a popular setup. Run Ollama headless as the model host \u2014 locally or on a VPS \u2014 and add it inside Jan as a custom OpenAI-compatible provider (base URL <code>http:\/\/your-host:11434\/v1<\/code>). Because both speak that API, the models you pulled in Ollama show up in Jan&#8217;s interface and the two slot together cleanly.<\/p>\n<h3>Which is faster, Ollama or Jan?<\/h3>\n<p>For the same model and quantization, they&#8217;re within a few percent, because both use llama.cpp. The bigger factor is the backend: on Apple Silicon, MLX (which both now support) runs roughly 1.4\u20131.8\u00d7 faster than the standard Metal path on mid-size models, and more on Mixture-of-Experts models. On NVIDIA, raw llama.cpp edges Ollama by roughly 3\u201310%.<\/p>\n<h3>Does Ollama have a graphical interface in 2026?<\/h3>\n<p>Yes, on macOS and Windows. Ollama added a native desktop GUI in v0.10.0 (July 2025) with chat, a model dropdown, streaming and file drag-and-drop. Linux, however, is still command-line only with no official native GUI.<\/p>\n<h3>Which one supports MCP (Model Context Protocol)?<\/h3>\n<p>Jan does, natively. It connects local models to MCP servers, and v0.8.0 added inline tool approval with citation cards \u2014 you see the exact arguments before you allow a tool call. Ollama does not support MCP natively in mid-2026; you&#8217;d integrate tools through its API or third-party agents instead.<\/p>\n<h3>Are Ollama and Jan free, and can I use them commercially?<\/h3>\n<p>Both are free and open source. Ollama is MIT-licensed (Ollama Inc.) and Jan is Apache 2.0 (Menlo Research) \u2014 both permissive licenses that allow commercial use with attribution. Neither imposes the copyleft obligations that some other open-source AI tools carry.<\/p>\n<h3>Where do the models come from?<\/h3>\n<p>Ollama pulls from its own curated registry using short names like <code>qwen3:8b<\/code>, and can import GGUF files. Jan uses Jan Hub plus direct Hugging Face GGUF access, which makes it easier to grab niche community fine-tunes and quantizations.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Bottom_line\"><\/span>R\u00e9sultat<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>There&#8217;s no single winner because they&#8217;re not really the same product. If you write code, run servers, or build agents, Ollama is the correct default \u2014 it&#8217;s the runtime everything else plugs into, it runs headless, and its integration story is unmatched. If you want a private, polished chat app you fully control, especially with MCP tools or on desktop Linux, Jan is the better pick and arguably the nicest open-source local-AI client right now.<\/p>\n<p>The honest move for many readers is to use both: Ollama as the engine, Jan as the face. If you only install one, let the question decide \u2014 &#8220;serve a model&#8221; means Ollama, &#8220;chat with a model&#8221; means Jan. Either way, in mid-2026 both are mature, fast, genuinely private, and free.<\/p>\n<p><!--related-block--><\/p>\n<div class=\"convly-related\">\n<h2><span class=\"ez-toc-section\" id=\"Related_articles\"><\/span>Articles connexes<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<ul>\n<li><a href=\"https:\/\/convly.ai\/fr\/lm-studio-complete-guide-2026\/\">LM Studio: The Complete Guide (2026)<\/a><\/li>\n<li><a href=\"https:\/\/convly.ai\/fr\/claude-5-new-ai-models-june-2026\/\">Is There a Claude 5? Claude Fable 5 and Every Major AI Model of June 2026<\/a><\/li>\n<li><a href=\"https:\/\/convly.ai\/fr\/what-is-ollama-complete-guide-2026\/\">What Is Ollama? The Complete Guide to Running LLMs Locally in 2026<\/a><\/li>\n<li><a href=\"https:\/\/convly.ai\/fr\/ollama-vs-lm-studio-vs-vllm-vs-llama-cpp-2026\/\">Ollama vs LM Studio vs vLLM vs llama.cpp: Which Should You Use in 2026?<\/a><\/li>\n<\/ul>\n<\/div>","protected":false},"excerpt":{"rendered":"<p>Ollama is the headless runtime developers wire into everything; Jan is the open-source desktop app that puts a ChatGPT-style UI and MCP tools in front of local models. Here&#8217;s how they actually stack up in mid-2026.<\/p>","protected":false},"author":1,"featured_media":1119,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[3],"tags":[759,650,750,256,760,259,423,651],"class_list":["post-1109","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-llms","tag-jan","tag-llama-cpp","tag-llms","tag-local-llm","tag-mcp","tag-ollama","tag-open-source-ai","tag-self-hosted-ai"],"_links":{"self":[{"href":"https:\/\/convly.ai\/fr\/wp-json\/wp\/v2\/posts\/1109","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/convly.ai\/fr\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/convly.ai\/fr\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/convly.ai\/fr\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/convly.ai\/fr\/wp-json\/wp\/v2\/comments?post=1109"}],"version-history":[{"count":1,"href":"https:\/\/convly.ai\/fr\/wp-json\/wp\/v2\/posts\/1109\/revisions"}],"predecessor-version":[{"id":1122,"href":"https:\/\/convly.ai\/fr\/wp-json\/wp\/v2\/posts\/1109\/revisions\/1122"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/convly.ai\/fr\/wp-json\/wp\/v2\/media\/1119"}],"wp:attachment":[{"href":"https:\/\/convly.ai\/fr\/wp-json\/wp\/v2\/media?parent=1109"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/convly.ai\/fr\/wp-json\/wp\/v2\/categories?post=1109"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/convly.ai\/fr\/wp-json\/wp\/v2\/tags?post=1109"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}