{"id":2173,"date":"2026-08-11T20:08:04","date_gmt":"2026-08-11T20:08:04","guid":{"rendered":"https:\/\/convly.ai\/?p=2173"},"modified":"2026-08-11T20:08:04","modified_gmt":"2026-08-11T20:08:04","slug":"vllm-docker-guide","status":"publish","type":"post","link":"https:\/\/convly.ai\/es\/vllm-docker-guide\/","title":{"rendered":"Docker vLLM: Ejecute un servidor de inferencia acelerado por GPU en minutos"},"content":{"rendered":"<div class=\"convly-tldr\">\n<ul>\n<li>Pull <code>vllm\/vllm-openai:latest<\/code> and run it with <code>--runtime nvidia --gpus all --ipc=host<\/code> to get a GPU-backed OpenAI-compatible server.<\/li>\n<li>Mount <code>~\/.cache\/huggingface<\/code> into the container so model weights survive container restarts.<\/li>\n<li>The server exposes an OpenAI-compatible API on port 8000; test it with <code>curl http:\/\/localhost:8000\/v1\/models<\/code>.<\/li>\n<li>The three most important tuning flags are <code>--tensor-parallel-size<\/code>, <code>--max-model-len<\/code>, and <code>--gpu-memory-utilization<\/code>.<\/li>\n<\/ul>\n<\/div>\n<p>vLLM publishes an official Docker image, <code>vllm\/vllm-openai<\/code>, that ships a ready-to-run OpenAI-compatible inference server. The fastest path: install the NVIDIA Container Toolkit on the host, then run the image with <code>--gpus all<\/code> and a Hugging Face model ID. Once the model downloads, the server is live on port 8000 and accepts the same requests as the OpenAI API.<\/p>\n<div id=\"ez-toc-container\" class=\"ez-toc-v2_0_86 counter-flat ez-toc-counter ez-toc-container-direction\">\n<label for=\"ez-toc-cssicon-toggle-item-6a7c5ec383356\" 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-6a7c5ec383356\"  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\/es\/vllm-docker-guide\/#Prerequisites\" >Prerequisites<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-2\" href=\"https:\/\/convly.ai\/es\/vllm-docker-guide\/#Installing_the_NVIDIA_Container_Toolkit\" >Installing the NVIDIA Container Toolkit<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-3\" href=\"https:\/\/convly.ai\/es\/vllm-docker-guide\/#The_Minimal_Run_Command\" >The Minimal Run Command<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-4\" href=\"https:\/\/convly.ai\/es\/vllm-docker-guide\/#Mounting_the_Hugging_Face_Cache\" >Mounting the Hugging Face Cache<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-5\" href=\"https:\/\/convly.ai\/es\/vllm-docker-guide\/#Key_vLLM_Server_Flags\" >Key vLLM Server Flags<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-6\" href=\"https:\/\/convly.ai\/es\/vllm-docker-guide\/#Exposing_and_Testing_the_OpenAI-Compatible_Endpoint\" >Exposing and Testing the OpenAI-Compatible Endpoint<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-7\" href=\"https:\/\/convly.ai\/es\/vllm-docker-guide\/#Docker_Compose_Example\" >Docker Compose Example<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-8\" href=\"https:\/\/convly.ai\/es\/vllm-docker-guide\/#Common_Failures_and_Fixes\" >Common Failures and Fixes<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-9\" href=\"https:\/\/convly.ai\/es\/vllm-docker-guide\/#Frequently_Asked_Questions\" >Frequently Asked Questions<\/a><\/li><\/ul><\/nav><\/div>\n<h2><span class=\"ez-toc-section\" id=\"Prerequisites\"><\/span>Prerequisites<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<ul>\n<li><strong>Docker Engine 20.10+<\/strong> \u2014 Docker Desktop on Windows and macOS works via the WSL2 backend.<\/li>\n<li><strong>NVIDIA GPU<\/strong> with a driver that supports CUDA 12.x. Run <code>nvidia-smi<\/code> to confirm; the &#8220;CUDA Version&#8221; shown is the maximum your driver supports.<\/li>\n<li><strong>NVIDIA Container Toolkit<\/strong> \u2014 the bridge that lets Docker see the GPU. See the next section.<\/li>\n<li>Enough VRAM for your target model. Use the <a href=\"https:\/\/convly.ai\/llm-vram-calculator\/\">VRAM calculator<\/a> to check before committing to a model download.<\/li>\n<\/ul>\n<h2><span class=\"ez-toc-section\" id=\"Installing_the_NVIDIA_Container_Toolkit\"><\/span>Installing the NVIDIA Container Toolkit<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>Skip this section if <code>docker run --gpus all nvidia\/cuda:12.0-base nvidia-smi<\/code> already works on your machine.<\/p>\n<p><strong>Linux (Ubuntu\/Debian):<\/strong><\/p>\n<pre><code>curl -fsSL https:\/\/nvidia.github.io\/libnvidia-container\/gpgkey | \n  sudo gpg --dearmor -o \/usr\/share\/keyrings\/nvidia-container-toolkit-keyring.gpg\n\ncurl -s -L https:\/\/nvidia.github.io\/libnvidia-container\/stable\/deb\/nvidia-container-toolkit.list | \n  sed 's#deb https:\/\/#deb [signed-by=\/usr\/share\/keyrings\/nvidia-container-toolkit-keyring.gpg] https:\/\/#g' | \n  sudo tee \/etc\/apt\/sources.list.d\/nvidia-container-toolkit.list\n\nsudo apt-get update &amp;&amp; sudo apt-get install -y nvidia-container-toolkit\nsudo nvidia-ctk runtime configure --runtime=docker\nsudo systemctl restart docker<\/code><\/pre>\n<p><strong>RHEL\/CentOS:<\/strong> Replace the <code>deb<\/code> repository URL with the <code>rpm<\/code> equivalent from NVIDIA&#8217;s documentation and use <code>dnf<\/code> in place of <code>apt-get<\/code>.<\/p>\n<p><strong>Windows (WSL2):<\/strong> Install the NVIDIA driver for Windows on the host \u2014 no separate container toolkit install is needed inside WSL2. Docker Desktop handles the passthrough automatically.<\/p>\n<p><strong>macOS:<\/strong> NVIDIA GPUs are not supported on macOS. vLLM does not run on Apple Silicon via Docker with GPU acceleration. For local inference on Apple hardware, consider a CPU-only build or a different runtime.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"The_Minimal_Run_Command\"><\/span>The Minimal Run Command<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<pre><code>docker run --runtime nvidia --gpus all \n  --ipc=host \n  -v ~\/.cache\/huggingface:\/root\/.cache\/huggingface \n  -p 8000:8000 \n  vllm\/vllm-openai:latest \n  --model meta-llama\/Meta-Llama-3-8B-Instruct<\/code><\/pre>\n<table>\n<thead>\n<tr>\n<th>Flag<\/th>\n<th>Why it matters<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>--runtime nvidia<\/code><\/td>\n<td>Routes GPU calls through the NVIDIA container runtime.<\/td>\n<\/tr>\n<tr>\n<td><code>--gpus all<\/code><\/td>\n<td>Exposes all host GPUs. Use <code>\"device=0,1\"<\/code> to target specific GPUs.<\/td>\n<\/tr>\n<tr>\n<td><code>--ipc=host<\/code><\/td>\n<td>Shares the host IPC namespace. Required for PyTorch shared memory; omitting it causes a <em>Bus error<\/em> or shared-memory crash.<\/td>\n<\/tr>\n<tr>\n<td><code>-v ~\/.cache\/huggingface:\u2026<\/code><\/td>\n<td>Mounts the host HF cache so weights survive container restarts.<\/td>\n<\/tr>\n<tr>\n<td><code>-p 8000:8000<\/code><\/td>\n<td>Exposes the OpenAI-compatible server on the host.<\/td>\n<\/tr>\n<tr>\n<td><code>--model<\/code><\/td>\n<td>Any Hugging Face model ID or a local path mounted into the container.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>To pull a gated model (Llama 3, Mistral, etc.), also pass <code>-e HUGGING_FACE_HUB_TOKEN=hf_yourtoken<\/code>. Store the token in a <code>.env<\/code> file and pass it with <code>--env-file .env<\/code> rather than inlining it in your shell history.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Mounting_the_Hugging_Face_Cache\"><\/span>Mounting the Hugging Face Cache<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>vLLM downloads model weights to <code>\/root\/.cache\/huggingface<\/code> inside the container. Without a volume mount, every <code>docker run<\/code> re-downloads the full model \u2014 often 5\u201380 GB. The mount line is:<\/p>\n<pre><code>-v ~\/.cache\/huggingface:\/root\/.cache\/huggingface<\/code><\/pre>\n<p>If your models live in a non-default location, set <code>-e HF_HOME=\/your\/path<\/code> and mount that path instead. For air-gapped environments, download the model with <code>huggingface-cli download<\/code> first, then pass <code>--model \/path\/in\/container<\/code> alongside a volume mount of the weights directory.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Key_vLLM_Server_Flags\"><\/span>Key vLLM Server Flags<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>These flags are passed after the image name \u2014 they are arguments to the vLLM server process, not to Docker.<\/p>\n<table>\n<thead>\n<tr>\n<th>Flag<\/th>\n<th>Default<\/th>\n<th>When to change it<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>--tensor-parallel-size N<\/code><\/td>\n<td>1<\/td>\n<td>Set to the number of GPUs for multi-GPU serving. The model&#8217;s attention heads must be divisible by N. Pair with <code>--gpus \"device=0,1,...\"<\/code> listing exactly N devices.<\/td>\n<\/tr>\n<tr>\n<td><code>--gpu-memory-utilization 0.X<\/code><\/td>\n<td>0.90<\/td>\n<td>Lower to 0.75\u20130.80 if you see OOM errors or share the GPU with other processes.<\/td>\n<\/tr>\n<tr>\n<td><code>--max-model-len N<\/code><\/td>\n<td>Model config<\/td>\n<td>Caps the KV cache size. Useful when a model&#8217;s default context (e.g. 128 k) would exhaust VRAM. Try <code>--max-model-len 8192<\/code> as a first reduction.<\/td>\n<\/tr>\n<tr>\n<td><code>--dtype auto<\/code><\/td>\n<td>auto<\/td>\n<td>Override with <code>bfloat16<\/code> or <code>float16<\/code> if auto-detection picks an unexpected precision.<\/td>\n<\/tr>\n<tr>\n<td><code>--quantization awq<\/code> \/ <code>gptq<\/code><\/td>\n<td>none<\/td>\n<td>Enable for pre-quantized model variants. Roughly halves VRAM at some quality cost.<\/td>\n<\/tr>\n<tr>\n<td><code>--port<\/code><\/td>\n<td>8000<\/td>\n<td>Change if 8000 is already occupied on the host.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Not sure whether your GPU has enough VRAM for a given model? The <a href=\"https:\/\/convly.ai\/vram-requirements-every-major-llm-2026\/\">VRAM requirements guide<\/a> lists common models, and the <a href=\"https:\/\/convly.ai\/llm-vram-calculator\/\">VRAM calculator<\/a> lets you plug in quantization and batch size. For hardware purchasing decisions, see the <a href=\"https:\/\/convly.ai\/best-gpus-for-local-llms-2026\/\">GPU recommendations guide<\/a>.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Exposing_and_Testing_the_OpenAI-Compatible_Endpoint\"><\/span>Exposing and Testing the OpenAI-Compatible Endpoint<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>Once the container prints <code>INFO: Application startup complete<\/code>, the API is live.<\/p>\n<pre><code># List loaded models\ncurl http:\/\/localhost:8000\/v1\/models\n\n# Text completion\ncurl http:\/\/localhost:8000\/v1\/completions \n  -H \"Content-Type: application\/json\" \n  -d '{\"model\": \"meta-llama\/Meta-Llama-3-8B-Instruct\", \"prompt\": \"The capital of France is\", \"max_tokens\": 20}'\n\n# Chat completion\ncurl http:\/\/localhost:8000\/v1\/chat\/completions \n  -H \"Content-Type: application\/json\" \n  -d '{\"model\": \"meta-llama\/Meta-Llama-3-8B-Instruct\", \"messages\": [{\"role\": \"user\", \"content\": \"Hello\"}]}'<\/code><\/pre>\n<p>Any OpenAI-compatible client \u2014 the Python <code>openai<\/code> SDK, LangChain, LlamaIndex \u2014 works by setting <code>base_url=\"http:\/\/localhost:8000\/v1\"<\/code> and providing any non-empty string as the <code>api_key<\/code>.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Docker_Compose_Example\"><\/span>Docker Compose Example<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>For persistent deployments, a Compose file is easier to manage than a long <code>docker run<\/code> command:<\/p>\n<pre><code>services:\n  vllm:\n    image: vllm\/vllm-openai:latest\n    runtime: nvidia\n    environment:\n      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}\n    volumes:\n      - ~\/.cache\/huggingface:\/root\/.cache\/huggingface\n    ports:\n      - \"8000:8000\"\n    ipc: host\n    deploy:\n      resources:\n        reservations:\n          devices:\n            - driver: nvidia\n              count: all\n              capabilities: [gpu]\n    command: >\n      --model meta-llama\/Meta-Llama-3-8B-Instruct\n      --gpu-memory-utilization 0.90\n      --max-model-len 8192<\/code><\/pre>\n<p>Start with <code>docker compose up -d<\/code>. The <code>deploy.resources<\/code> block is the Compose v3 equivalent of <code>--gpus all<\/code>.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Common_Failures_and_Fixes\"><\/span>Common Failures and Fixes<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<table>\n<thead>\n<tr>\n<th>Error<\/th>\n<th>Cause<\/th>\n<th>Fix<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><em>Bus error<\/em> or <em>\/dev\/shm too small<\/em><\/td>\n<td>Docker&#8217;s default <code>\/dev\/shm<\/code> is 64 MB \u2014 too small for PyTorch.<\/td>\n<td>Add <code>--ipc=host<\/code> to the run command. Alternatively use <code>--shm-size=8g<\/code> if you cannot share the host IPC namespace.<\/td>\n<\/tr>\n<tr>\n<td><em>CUDA error: no kernel image is available<\/em><\/td>\n<td>The CUDA version compiled into the vLLM image exceeds what your driver supports.<\/td>\n<td>Run <code>nvidia-smi<\/code> to find your max supported CUDA version, then pin to a matching versioned image tag (e.g. <code>vllm\/vllm-openai:v0.5.5<\/code>).<\/td>\n<\/tr>\n<tr>\n<td><em>torch.cuda.OutOfMemoryError<\/em><\/td>\n<td>Model weights plus KV cache exceed available VRAM.<\/td>\n<td>Try <code>--max-model-len 4096<\/code> first. Then lower <code>--gpu-memory-utilization<\/code> to 0.80. If still OOM, use a quantized variant or a larger GPU.<\/td>\n<\/tr>\n<tr>\n<td><em>permission denied<\/em> on cache directory<\/td>\n<td>Container runs as root; host directory owned by another user.<\/td>\n<td>Run <code>chmod -R a+rw ~\/.cache\/huggingface<\/code> on the host, or use a named Docker volume instead of a bind mount.<\/td>\n<\/tr>\n<tr>\n<td>Container starts but <code>curl<\/code> returns connection refused<\/td>\n<td>Model still loading, or <code>-p 8000:8000<\/code> missing.<\/td>\n<td>Wait for the <em>Application startup complete<\/em> log line. Verify the port mapping is present in your run command.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\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>Which vLLM Docker image tag should I use?<\/h3>\n<p><code>vllm\/vllm-openai:latest<\/code> tracks the most recent release and is fine for experimentation. For production, pin to a specific version tag (e.g. <code>v0.6.0<\/code>) so builds are reproducible. Each release tag on Docker Hub indicates the CUDA version it was compiled against, which must be less than or equal to the version your driver supports.<\/p>\n<h3>Can I run vLLM in Docker without a GPU?<\/h3>\n<p>The standard image requires an NVIDIA GPU. CPU-only inference is possible by building vLLM from source with <code>VLLM_TARGET_DEVICE=cpu<\/code>, but throughput is orders of magnitude slower and not practical for serving. For CPU-only local inference, llama.cpp or Ollama are more suitable alternatives \u2014 see the <a href=\"https:\/\/convly.ai\/what-is-ollama-complete-guide-2026\/\">Ollama guide<\/a> for comparison.<\/p>\n<h3>How do I run a gated model that requires a Hugging Face token?<\/h3>\n<p>Pass the token as an environment variable: <code>-e HUGGING_FACE_HUB_TOKEN=hf_yourtoken<\/code>. Store it in a <code>.env<\/code> file and reference it with <code>--env-file .env<\/code> to avoid leaking it in shell history. The server uses it during the initial model download; it is not required after the weights are cached locally.<\/p>\n<h3>What does &#8211;tensor-parallel-size do and when do I need it?<\/h3>\n<p>Tensor parallelism shards model weight matrices across multiple GPUs, enabling models too large for a single card. Set it to the number of GPUs you want to use (2 or 4 are common). The number must match the GPU count passed to <code>--gpus<\/code>, and the model&#8217;s attention heads must be divisible by that number.<\/p>\n<h3>Is running vLLM in Docker cost-effective compared with a managed API?<\/h3>\n<p>It depends entirely on your request volume. Self-hosting has high fixed costs (GPU instance or hardware) but near-zero marginal cost per request. Managed APIs have zero fixed cost but charge per token. Use the <a href=\"https:\/\/convly.ai\/self-hosting-vs-api-calculator\/\">self-hosting vs API calculator<\/a> to find your break-even point before committing to infrastructure.<\/p>\n<h3>How do I serve multiple models at once?<\/h3>\n<p>Run one container per model, each mapped to a different host port (e.g. 8000, 8001). vLLM does not currently support multi-model serving from a single process. Place a reverse proxy such as nginx or Caddy in front of the containers to route requests by model name to the correct port.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Pull vllm\/vllm-openai:latest and run it with &#8211;runtime nvidia &#8211;gpus all &#8211;ipc=host to get a GPU-backed OpenAI-compatible server. Mount ~\/.cache\/huggingface into [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":2174,"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-2173","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-ai-news"],"_links":{"self":[{"href":"https:\/\/convly.ai\/es\/wp-json\/wp\/v2\/posts\/2173","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/convly.ai\/es\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/convly.ai\/es\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/convly.ai\/es\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/convly.ai\/es\/wp-json\/wp\/v2\/comments?post=2173"}],"version-history":[{"count":1,"href":"https:\/\/convly.ai\/es\/wp-json\/wp\/v2\/posts\/2173\/revisions"}],"predecessor-version":[{"id":2175,"href":"https:\/\/convly.ai\/es\/wp-json\/wp\/v2\/posts\/2173\/revisions\/2175"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/convly.ai\/es\/wp-json\/wp\/v2\/media\/2174"}],"wp:attachment":[{"href":"https:\/\/convly.ai\/es\/wp-json\/wp\/v2\/media?parent=2173"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/convly.ai\/es\/wp-json\/wp\/v2\/categories?post=2173"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/convly.ai\/es\/wp-json\/wp\/v2\/tags?post=2173"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}