{"id":2106,"date":"2026-08-04T20:04:46","date_gmt":"2026-08-04T20:04:46","guid":{"rendered":"https:\/\/convly.ai\/?p=2106"},"modified":"2026-08-04T20:04:46","modified_gmt":"2026-08-04T20:04:46","slug":"what-is-vllm-explained-2026","status":"publish","type":"post","link":"https:\/\/convly.ai\/pt\/what-is-vllm-explained-2026\/","title":{"rendered":"O que \u00e9 vLLM? Um guia pr\u00e1tico sobre o mecanismo de infer\u00eancia de LLM de alta taxa de processamento"},"content":{"rendered":"<div class=\"convly-tldr\">\n<ul>\n<li><strong>vLLM is an open-source inference engine for serving LLMs on GPUs at high throughput<\/strong>, exposing them through an OpenAI-compatible HTTP API.<\/li>\n<li>Its two core techniques \u2014 <strong>PagedAttention<\/strong> and <strong>continuous batching<\/strong> \u2014 let one GPU handle many concurrent requests without wasting VRAM.<\/li>\n<li>Install with <code>pip install vllm<\/code> in a fresh Python environment on Linux (NVIDIA GPU, compute capability 7.0+), then start a server with <code>vllm serve &lt;model&gt;<\/code>.<\/li>\n<li>It is built for serving many users or apps. For a personal chatbot on a laptop, <a href=\"https:\/\/convly.ai\/what-is-ollama-complete-guide-2026\/\">Ollama<\/a> or LM Studio is the better tool.<\/li>\n<\/ul>\n<\/div>\n<p>vLLM is an open-source inference and serving engine for large language models. It loads a model onto one or more GPUs and exposes it through an OpenAI-compatible HTTP API, using two techniques \u2014 PagedAttention and continuous batching \u2014 to serve many concurrent requests at far higher throughput than naive serving. It was created at UC Berkeley&#8217;s Sky Computing Lab and released in 2023.<\/p>\n<div id=\"ez-toc-container\" class=\"ez-toc-v2_0_85 counter-flat ez-toc-counter ez-toc-container-direction\">\n<label for=\"ez-toc-cssicon-toggle-item-6a72765150ddc\" 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-6a72765150ddc\"  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\/pt\/what-is-vllm-explained-2026\/#What_vLLM_is_and_who_it_is_for\" >What vLLM is and who it is for<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-2\" href=\"https:\/\/convly.ai\/pt\/what-is-vllm-explained-2026\/#PagedAttention_in_plain_terms\" >PagedAttention, in plain terms<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-3\" href=\"https:\/\/convly.ai\/pt\/what-is-vllm-explained-2026\/#Continuous_batching\" >Continuous batching<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-4\" href=\"https:\/\/convly.ai\/pt\/what-is-vllm-explained-2026\/#Installing_vLLM_the_constraints_that_trip_people_up\" >Installing vLLM: the constraints that trip people up<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-5\" href=\"https:\/\/convly.ai\/pt\/what-is-vllm-explained-2026\/#Running_a_server_vllm_serve\" >Running a server: vllm serve<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-6\" href=\"https:\/\/convly.ai\/pt\/what-is-vllm-explained-2026\/#The_OpenAI-compatible_API\" >The OpenAI-compatible API<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-7\" href=\"https:\/\/convly.ai\/pt\/what-is-vllm-explained-2026\/#When_Ollama_or_llamacpp_is_the_better_choice\" >When Ollama or llama.cpp is the better choice<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-8\" href=\"https:\/\/convly.ai\/pt\/what-is-vllm-explained-2026\/#Frequently_asked_questions\" >Frequently asked questions<\/a><\/li><\/ul><\/nav><\/div>\n<h2><span class=\"ez-toc-section\" id=\"What_vLLM_is_and_who_it_is_for\"><\/span>What vLLM is and who it is for<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>Think of vLLM as the production counterpart to desktop tools like Ollama. Both take a model and answer requests, but they optimize for opposite things. Ollama optimizes for one person getting a response on modest hardware. vLLM optimizes for <em>throughput<\/em>: total tokens generated per second across dozens or hundreds of simultaneous requests hitting the same GPU.<\/p>\n<p>That makes vLLM the right tool when you are:<\/p>\n<ul>\n<li>Serving an LLM behind an internal or public API used by multiple people or services<\/li>\n<li>Running batch jobs \u2014 classification, extraction, synthetic data generation \u2014 over large datasets<\/li>\n<li>Replacing a paid API with a self-hosted open-weight model to cut per-token costs (the <a href=\"https:\/\/convly.ai\/self-hosting-vs-api-calculator\/\">self-hosting vs API break-even calculator<\/a> helps you check whether the GPU bill actually beats the API bill at your volume)<\/li>\n<\/ul>\n<p>And the wrong tool when you want a chat assistant on your own laptop, occasional single-user inference, or anything on a machine without a serious GPU. vLLM assumes a server: Linux, an NVIDIA GPU as the default path (AMD ROCm, Intel, TPU, and CPU backends exist but are less traveled), and a workload with concurrency.<\/p>\n<p>At launch in 2023, vLLM&#8217;s benchmarks showed up to 24\u00d7 the throughput of serving with plain Hugging Face Transformers and roughly 2\u20133.5\u00d7 that of the serving systems of the day. Exact numbers vary by model, hardware, and workload \u2014 but the reason for the gap is worth understanding, because it tells you when vLLM matters.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"PagedAttention_in_plain_terms\"><\/span>PagedAttention, in plain terms<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>When an LLM generates text, it keeps a <strong>KV cache<\/strong> in GPU memory: the attention keys and values for every token in every active conversation. This cache grows with each generated token and, for long contexts, can consume more VRAM than the model weights themselves.<\/p>\n<p>Before vLLM, serving engines allocated each request one contiguous slab of memory sized for the <em>maximum possible<\/em> sequence length, because they couldn&#8217;t know in advance how long the output would be. Most requests finish well short of the maximum, so most of that reserved memory sat idle. The vLLM paper measured 60\u201380% of KV cache memory wasted in prior systems through this kind of fragmentation.<\/p>\n<p>PagedAttention borrows the fix from operating systems: virtual memory paging. The KV cache is split into small fixed-size blocks (16 tokens each by default) that are allocated on demand and don&#8217;t need to be contiguous. A block table maps each sequence&#8217;s logical positions to whatever physical blocks are free \u2014 exactly like an OS mapping virtual pages to physical RAM. Memory waste drops to under 4%, and blocks can even be shared between sequences (useful when sampling several completions from one prompt).<\/p>\n<p>The practical consequence: far more concurrent sequences fit in the same VRAM. More sequences in memory means bigger effective batches, and bigger batches are what keep a GPU busy. That is the entire throughput story \u2014 PagedAttention doesn&#8217;t make any single request faster; it lets many more requests run at once.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Continuous_batching\"><\/span>Continuous batching<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>The second technique attacks scheduling rather than memory. Naive batching groups requests, runs the whole batch to completion, then starts the next batch \u2014 so a request that finishes in 20 tokens waits for the one generating 2,000, and new arrivals queue outside. <strong>Continuous batching<\/strong> (also called iteration-level scheduling) re-forms the batch at every generation step: finished sequences leave immediately and waiting requests join immediately.<\/p>\n<p>The GPU stays saturated, short requests aren&#8217;t held hostage by long ones, and latency under load improves alongside throughput. PagedAttention and continuous batching compound: the first fits more sequences into memory, the second keeps that capacity actually working.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Installing_vLLM_the_constraints_that_trip_people_up\"><\/span>Installing vLLM: the constraints that trip people up<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>The install is one command, but three constraints cause most of the failed installs:<\/p>\n<ol>\n<li><strong>Python version.<\/strong> Recent releases target roughly the Python 3.9\u20133.12 range, and the supported window shifts between releases. If <code>pip<\/code> reports no matching distribution, your Python version is the first suspect.<\/li>\n<li><strong>CUDA version.<\/strong> The prebuilt wheels are compiled against a specific CUDA major version (CUDA 12.x for current releases). You need a recent NVIDIA driver; wheels for other CUDA versions exist for some releases via special index URLs documented in the vLLM docs.<\/li>\n<li><strong>PyTorch conflicts.<\/strong> vLLM pins its own PyTorch version. Installing it into an environment that already has a different Torch build is the classic way to end up with cryptic import errors. Always use a fresh virtual environment.<\/li>\n<\/ol>\n<p>Hardware-wise, the mainstream path requires an NVIDIA GPU with compute capability 7.0 or higher \u2014 V100, T4, RTX 20-series and newer. If you&#8217;re choosing hardware, see the guide to the <a href=\"https:\/\/convly.ai\/best-gpus-for-local-llms-2026\/\">best GPUs for running LLMs locally<\/a>.<\/p>\n<h3>Linux (the supported platform)<\/h3>\n<pre><code>python3 -m venv vllm-env\nsource vllm-env\/bin\/activate\npip install vllm<\/code><\/pre>\n<p>The vLLM docs also recommend <code>uv<\/code> (<code>uv venv<\/code> then <code>uv pip install vllm<\/code>), which resolves the pinned dependencies faster. Either way, a clean environment is the point.<\/p>\n<h3>Windows: use WSL2 or Docker<\/h3>\n<p>There is no native Windows build. The working setups are <strong>WSL2<\/strong> with an Ubuntu distribution (NVIDIA&#8217;s Windows driver passes CUDA through to WSL2, so the Linux instructions above work inside it) or <strong>Docker Desktop<\/strong> with GPU support enabled, using the official image:<\/p>\n<pre><code>docker run --gpus all -p 8000:8000 vllm\/vllm-openai --model Qwen\/Qwen2.5-7B-Instruct<\/code><\/pre>\n<h3>macOS: not the right tool<\/h3>\n<p>vLLM has no Metal\/Apple GPU backend. An experimental CPU build can be compiled from source, but it defeats the purpose of a throughput engine. On a Mac, use <a href=\"https:\/\/convly.ai\/lm-studio-complete-guide-2026\/\">LM Studio<\/a> or Ollama instead \u2014 both use Apple Silicon&#8217;s GPU properly.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Running_a_server_vllm_serve\"><\/span>Running a server: vllm serve<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>One command starts an inference server (the model downloads from Hugging Face on first run):<\/p>\n<pre><code>vllm serve Qwen\/Qwen2.5-7B-Instruct<\/code><\/pre>\n<p>That serves the model on port 8000. The flags you&#8217;ll actually reach for:<\/p>\n<table>\n<thead>\n<tr>\n<th>Flag<\/th>\n<th>What it does<\/th>\n<th>When you need it<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>--max-model-len<\/code><\/td>\n<td>Caps the context length, shrinking the KV cache reservation<\/td>\n<td>The most common fix when startup fails with an out-of-memory error<\/td>\n<\/tr>\n<tr>\n<td><code>--gpu-memory-utilization<\/code><\/td>\n<td>Fraction of VRAM vLLM pre-allocates (default 0.9)<\/td>\n<td>Lower it if the GPU is shared with anything else<\/td>\n<\/tr>\n<tr>\n<td><code>--tensor-parallel-size<\/code><\/td>\n<td>Splits the model across N GPUs<\/td>\n<td>Models too large for one card<\/td>\n<\/tr>\n<tr>\n<td><code>--quantization<\/code><\/td>\n<td>Selects a quantization method (AWQ, GPTQ, FP8\u2026)<\/td>\n<td>Usually auto-detected from the checkpoint; set explicitly if not<\/td>\n<\/tr>\n<tr>\n<td><code>--dtype<\/code><\/td>\n<td>Weight precision (auto, float16, bfloat16)<\/td>\n<td>Older GPUs without bfloat16 support<\/td>\n<\/tr>\n<tr>\n<td><code>--api-key<\/code><\/td>\n<td>Requires a bearer token on every request<\/td>\n<td>Any server reachable beyond localhost<\/td>\n<\/tr>\n<tr>\n<td><code>--port<\/code><\/td>\n<td>Listening port (default 8000)<\/td>\n<td>Port conflicts, multiple models on one host<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Note that vLLM <em>pre-allocates<\/em> most of the GPU by design \u2014 a mostly-full VRAM readout is normal, not a leak. Before picking a model, check that weights plus KV cache fit your card with the <a href=\"https:\/\/convly.ai\/llm-vram-calculator\/\">VRAM calculator<\/a>; as a rough rule, FP16 weights need about 2 GB per billion parameters, 8-bit about half that, plus headroom for the cache.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"The_OpenAI-compatible_API\"><\/span>The OpenAI-compatible API<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>The server implements the OpenAI API surface: <code>\/v1\/chat\/completions<\/code>, <code>\/v1\/completions<\/code>, <code>\/v1\/models<\/code>, and <code>\/v1\/embeddings<\/code> (for embedding models). Anything built against the OpenAI SDK works by changing the base URL:<\/p>\n<pre><code>curl http:\/\/localhost:8000\/v1\/chat\/completions \n  -H \"Content-Type: application\/json\" \n  -d '{\n    \"model\": \"Qwen\/Qwen2.5-7B-Instruct\",\n    \"messages\": [{\"role\": \"user\", \"content\": \"Explain PagedAttention in one sentence.\"}]\n  }'<\/code><\/pre>\n<p>In Python, <code>OpenAI(base_url=\"http:\/\/localhost:8000\/v1\", api_key=\"none\")<\/code> is the whole migration. This compatibility is a large part of vLLM&#8217;s adoption: existing tooling, agents, and frameworks work unmodified.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"When_Ollama_or_llamacpp_is_the_better_choice\"><\/span>When Ollama or llama.cpp is the better choice<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<table>\n<thead>\n<tr>\n<th><\/th>\n<th>vLLM<\/th>\n<th>Ollama<\/th>\n<th>llama.cpp<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Built for<\/td>\n<td>Multi-user GPU serving<\/td>\n<td>Personal\/desktop use<\/td>\n<td>Portability, CPU+GPU, embedding in apps<\/td>\n<\/tr>\n<tr>\n<td>Hardware<\/td>\n<td>Server GPUs (NVIDIA-first)<\/td>\n<td>Anything, incl. Apple Silicon<\/td>\n<td>Anything, incl. phones<\/td>\n<\/tr>\n<tr>\n<td>Model format<\/td>\n<td>Hugging Face safetensors (AWQ\/GPTQ\/FP8)<\/td>\n<td>GGUF<\/td>\n<td>GGUF<\/td>\n<\/tr>\n<tr>\n<td>Concurrency<\/td>\n<td>Excellent \u2014 the whole point<\/td>\n<td>Limited<\/td>\n<td>Limited<\/td>\n<\/tr>\n<tr>\n<td>Setup<\/td>\n<td>Python\/CUDA environment<\/td>\n<td>One installer<\/td>\n<td>Single binary \/ library<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Choose <strong>Ollama<\/strong> when the user count is one and the hardware is a laptop or desktop \u2014 its setup is a single installer and it runs quantized GGUF models comfortably on CPUs and Apple Silicon (see the <a href=\"https:\/\/convly.ai\/what-is-ollama-complete-guide-2026\/\">Ollama complete guide<\/a>). Choose <strong>llama.cpp<\/strong> directly when you need maximum portability or want to embed inference inside another application. Choose <strong>vLLM<\/strong> when requests arrive concurrently and tokens-per-second-per-dollar is the metric. A single-user workload gains little from PagedAttention; a 50-user workload gains enormously.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Frequently_asked_questions\"><\/span>Frequently asked questions<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<h3>Is vLLM free?<\/h3>\n<p>Yes. vLLM is open source under the Apache 2.0 license, originally from UC Berkeley and now developed as a community project under the PyTorch Foundation. There is no paid tier; your costs are hardware and electricity.<\/p>\n<h3>Can vLLM run GGUF models like Ollama does?<\/h3>\n<p>GGUF support exists but is experimental and not the intended path. vLLM is built around standard Hugging Face checkpoints (safetensors), with quantization via AWQ, GPTQ, or FP8 checkpoints instead. If your models only exist as GGUF files, Ollama or llama.cpp is the more natural fit.<\/p>\n<h3>Does vLLM work without an NVIDIA GPU?<\/h3>\n<p>There are backends for AMD ROCm, Intel hardware, Google TPUs, AWS Neuron, and CPUs, but the NVIDIA CUDA path is by far the most mature and best documented. CPU-only vLLM works for testing, not for the throughput serving the engine exists for.<\/p>\n<h3>How much VRAM does vLLM need?<\/h3>\n<p>Enough for the model weights plus KV cache: roughly 2 GB per billion parameters at FP16, about half that at 8-bit, plus cache headroom that grows with context length and concurrency. A 7B model at FP16 fits a 24 GB card comfortably; a 70B model needs multiple GPUs or aggressive quantization. The <a href=\"https:\/\/convly.ai\/vram-requirements-every-major-llm-2026\/\">VRAM requirements by model<\/a> reference has per-model numbers.<\/p>\n<h3>How does vLLM compare to TensorRT-LLM, SGLang, or TGI?<\/h3>\n<p>They occupy the same category \u2014 production inference engines. vLLM generally offers the broadest model support, easiest setup, and largest community; TensorRT-LLM can extract more peak performance from NVIDIA hardware at the cost of a heavier build-and-tune workflow; SGLang is a strong competitor, particularly for structured output. Benchmark on your own model and workload before committing \u2014 rankings shift between releases.<\/p>\n<h3>Can I fine-tune models with vLLM?<\/h3>\n<p>No \u2014 vLLM is inference-only. It is often used as the fast generation backend inside RLHF training frameworks, but the training itself happens elsewhere. Fine-tune with tools like Hugging Face TRL, Axolotl, or Unsloth, then serve the resulting checkpoint with vLLM.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>vLLM is an open-source inference engine for serving LLMs on GPUs at high throughput, exposing them through an OpenAI-compatible HTTP [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":2107,"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":[7],"tags":[],"class_list":["post-2106","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-ai-news"],"_links":{"self":[{"href":"https:\/\/convly.ai\/pt\/wp-json\/wp\/v2\/posts\/2106","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/convly.ai\/pt\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/convly.ai\/pt\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/convly.ai\/pt\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/convly.ai\/pt\/wp-json\/wp\/v2\/comments?post=2106"}],"version-history":[{"count":1,"href":"https:\/\/convly.ai\/pt\/wp-json\/wp\/v2\/posts\/2106\/revisions"}],"predecessor-version":[{"id":2108,"href":"https:\/\/convly.ai\/pt\/wp-json\/wp\/v2\/posts\/2106\/revisions\/2108"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/convly.ai\/pt\/wp-json\/wp\/v2\/media\/2107"}],"wp:attachment":[{"href":"https:\/\/convly.ai\/pt\/wp-json\/wp\/v2\/media?parent=2106"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/convly.ai\/pt\/wp-json\/wp\/v2\/categories?post=2106"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/convly.ai\/pt\/wp-json\/wp\/v2\/tags?post=2106"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}