{"id":2135,"date":"2026-08-07T14:04:12","date_gmt":"2026-08-07T14:04:12","guid":{"rendered":"https:\/\/convly.ai\/?p=2135"},"modified":"2026-08-07T14:04:12","modified_gmt":"2026-08-07T14:04:12","slug":"sglang-vs-vllm-comparison","status":"publish","type":"post","link":"https:\/\/convly.ai\/es\/sglang-vs-vllm-comparison\/","title":{"rendered":"SGLang frente a vLLM: \u00bfqu\u00e9 motor de servicio de modelos de lenguaje grande elegir en 2026?"},"content":{"rendered":"<div class=\"convly-tldr\">\n<ul>\n<li><strong>vLLM is the safer default<\/strong>: broadest model and hardware support, biggest ecosystem, least deployment friction.<\/li>\n<li><strong>Pick SGLang<\/strong> when your traffic reuses prompt prefixes heavily (agents, multi-turn chat, big system prompts) or produces lots of structured JSON output \u2014 RadixAttention and jump-forward decoding win there.<\/li>\n<li>The performance gap is workload-dependent and shrinks with every release. Both speak the OpenAI API, so benchmarking one against the other on your real traffic is cheap.<\/li>\n<li>Neither runs natively on Windows or macOS \u2014 use Linux (or WSL2), or a desktop tool like Ollama\/LM Studio for local use.<\/li>\n<\/ul>\n<\/div>\n<p>vLLM and SGLang are the two leading open-source engines for serving large language models on your own GPUs, and for most teams <strong>vLLM is the safer default<\/strong>: more models, more hardware backends, a larger ecosystem. Choose <strong>SGLang<\/strong> when your traffic is dominated by shared prompt prefixes \u2014 agents, multi-turn chat, heavy system prompts \u2014 or by structured JSON output, where its RadixAttention cache and grammar-based decoding give it a real edge. Both expose an OpenAI-compatible API, so switching later costs almost nothing.<\/p>\n<p>This guide compares them the way you would actually choose: what each project optimises for, how RadixAttention and PagedAttention differ in practice, where each wins on throughput and latency, and a clear recommendation by workload.<\/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-6a761ae1c5dd3\" 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-6a761ae1c5dd3\"  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\/sglang-vs-vllm-comparison\/#What_Each_Project_Optimises_For\" >What Each Project Optimises For<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-2\" href=\"https:\/\/convly.ai\/es\/sglang-vs-vllm-comparison\/#RadixAttention_vs_PagedAttention_in_Plain_Terms\" >RadixAttention vs 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\/es\/sglang-vs-vllm-comparison\/#Throughput_and_Latency_Where_Each_Wins\" >Throughput and Latency: Where Each Wins<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-4\" href=\"https:\/\/convly.ai\/es\/sglang-vs-vllm-comparison\/#Structured_and_Constrained_Output\" >Structured and Constrained Output<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-5\" href=\"https:\/\/convly.ai\/es\/sglang-vs-vllm-comparison\/#Ecosystem_Hardware_Support_and_Deployment_Friction\" >Ecosystem, Hardware Support and Deployment Friction<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-6\" href=\"https:\/\/convly.ai\/es\/sglang-vs-vllm-comparison\/#Platform_Support\" >Platform Support<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-7\" href=\"https:\/\/convly.ai\/es\/sglang-vs-vllm-comparison\/#Which_to_Pick_by_Workload\" >Which to Pick, by Workload<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-8\" href=\"https:\/\/convly.ai\/es\/sglang-vs-vllm-comparison\/#Frequently_Asked_Questions\" >Frequently Asked Questions<\/a><\/li><\/ul><\/nav><\/div>\n<h2><span class=\"ez-toc-section\" id=\"What_Each_Project_Optimises_For\"><\/span>What Each Project Optimises For<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><strong>vLLM<\/strong> started at UC Berkeley in 2023 as the reference implementation of the PagedAttention paper and has since become the de facto standard open serving engine, now a PyTorch Foundation project. Its priorities are breadth and robustness: run nearly every open-weight model on nearly every accelerator \u2014 NVIDIA CUDA, AMD ROCm, Intel, Google TPU, AWS Neuron, even x86 CPU \u2014 with strong throughput out of the box. New model families usually get vLLM support on or near day one.<\/p>\n<p><strong>SGLang<\/strong> comes from the LMSYS team behind Chatbot Arena. It optimises for two specific things: <em>KV-cache reuse<\/em> (RadixAttention) and <em>fast structured generation<\/em>. The name is short for Structured Generation Language \u2014 it originally shipped with a Python DSL for chaining and branching LLM calls \u2014 but the serving runtime is what most people deploy today. It has serious production credentials: it was among the engines DeepSeek recommended at the V3 launch, and it is known for aggressive multi-GPU optimisations (prefill\/decode disaggregation, large-scale expert parallelism for MoE models).<\/p>\n<h2><span class=\"ez-toc-section\" id=\"RadixAttention_vs_PagedAttention_in_Plain_Terms\"><\/span>RadixAttention vs PagedAttention, in Plain Terms<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>The two headline techniques solve different problems, and the names invite a false either\/or.<\/p>\n<p><strong>PagedAttention (vLLM) is memory management.<\/strong> It stores the KV cache in fixed-size blocks, like an operating system pages virtual memory, instead of reserving one big contiguous chunk per request. That nearly eliminates fragmentation, so far more concurrent sequences fit in the same VRAM, and bigger batches mean higher throughput. It is about <em>fitting more in<\/em>.<\/p>\n<p><strong>RadixAttention (SGLang) is memory reuse.<\/strong> It organises the KV cache as a radix tree keyed by token sequences. When a new request arrives, the engine walks the tree, finds the longest matching prefix, and skips recomputing it. System prompts, few-shot examples, conversation history, and agent scratchpads that repeat across requests are prefill-computed once and reused. It is about <em>computing less<\/em>.<\/p>\n<p>In 2026 the two engines have converged more than the branding suggests: vLLM has automatic prefix caching (enabled by default in recent versions), and SGLang also pages its memory. The remaining practical difference is that SGLang was designed around reuse from day one \u2014 its scheduler is cache-aware, ordering and routing requests to maximise hit rate. The rule of thumb: <strong>the larger the share of your typical prompt that repeats across requests, the more SGLang&#8217;s design pays off<\/strong>.<\/p>\n<p>Either way, the KV cache competes with model weights for the same GPU memory, and concurrency headroom is what a serving engine actually buys you. Use the <a href=\"https:\/\/convly.ai\/llm-vram-calculator\/\">VRAM calculator<\/a> to estimate how much memory a given model plus context leaves for cache before you size hardware.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Throughput_and_Latency_Where_Each_Wins\"><\/span>Throughput and Latency: Where Each Wins<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<table>\n<thead>\n<tr>\n<th>Workload<\/th>\n<th>Typically faster<\/th>\n<th>Why<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Multi-turn chat, agent loops, large shared system prompts<\/td>\n<td>SGLang<\/td>\n<td>RadixAttention skips re-prefilling repeated prefixes, cutting time-to-first-token and freeing compute<\/td>\n<\/tr>\n<tr>\n<td>One-off prompts with little overlap (unique documents, batch summarisation)<\/td>\n<td>Roughly even<\/td>\n<td>Both use continuous batching and chunked prefill; cache reuse rarely triggers<\/td>\n<\/tr>\n<tr>\n<td>High-volume JSON \/ constrained output<\/td>\n<td>SGLang<\/td>\n<td>Jump-forward decoding emits grammar-forced tokens without a model forward pass<\/td>\n<\/tr>\n<tr>\n<td>Mixed model zoo, exotic quantisation, non-NVIDIA hardware<\/td>\n<td>vLLM<\/td>\n<td>Broader backend and format coverage means fewer unoptimised fallback paths<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Treat any specific throughput numbers you find online as version-bound. Both projects ship optimisations continuously, and each has published benchmarks where it beats the other. The honest answer is that on cache-friendly traffic SGLang usually leads, on cold-cache traffic they are close, and the only benchmark that matters is your own: both ship load-testing tools (vLLM&#8217;s <code>vllm bench serve<\/code>, SGLang&#8217;s <code>python -m sglang.bench_serving<\/code>) that replay realistic request streams.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Structured_and_Constrained_Output\"><\/span>Structured and Constrained Output<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>Both engines can force output to match a JSON schema, regular expression, or grammar, exposed through the OpenAI-style <code>response_format<\/code> parameter plus engine-specific extensions.<\/p>\n<p>SGLang pioneered the fast path here: it compiles constraints into a compressed finite-state machine and uses <em>jump-forward decoding<\/em> \u2014 when the grammar makes the next several tokens deterministic (braces, quotes, fixed key names), it appends them directly instead of running the model for each one. For extraction pipelines producing token-heavy JSON, that is a meaningful speedup.<\/p>\n<p>vLLM supports the same class of constraints through pluggable grammar backends (xgrammar, guidance, outlines), and since both projects adopted xgrammar as a default backend the gap has narrowed considerably. Verdict: both are production-ready; SGLang retains an edge on heavily structured, high-volume workloads.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Ecosystem_Hardware_Support_and_Deployment_Friction\"><\/span>Ecosystem, Hardware Support and Deployment Friction<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<table>\n<thead>\n<tr>\n<th><\/th>\n<th>vLLM<\/th>\n<th>SGLang<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Origin<\/td>\n<td>UC Berkeley; PyTorch Foundation project<\/td>\n<td>LMSYS (Chatbot Arena team)<\/td>\n<\/tr>\n<tr>\n<td>Hardware<\/td>\n<td>NVIDIA, AMD ROCm, Intel, Google TPU, AWS Neuron, x86 CPU<\/td>\n<td>NVIDIA first-class, AMD ROCm supported; others less mature<\/td>\n<\/tr>\n<tr>\n<td>Model coverage<\/td>\n<td>Widest of any engine, including many multimodal and niche architectures<\/td>\n<td>All major families (Llama, Qwen, DeepSeek, Mistral, GPT-OSS\u2026), shorter tail<\/td>\n<\/tr>\n<tr>\n<td>Quantisation<\/td>\n<td>FP8, AWQ, GPTQ, INT8, bitsandbytes, more<\/td>\n<td>FP8, AWQ, GPTQ; narrower list<\/td>\n<\/tr>\n<tr>\n<td>API<\/td>\n<td>OpenAI-compatible, default port 8000<\/td>\n<td>OpenAI-compatible, default port 30000<\/td>\n<\/tr>\n<tr>\n<td>Docker image<\/td>\n<td><code>vllm\/vllm-openai<\/code><\/td>\n<td><code>lmsysorg\/sglang<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Getting started is a one-liner for each on a CUDA Linux box:<\/p>\n<p><code>pip install vllm<\/code> then <code>vllm serve Qwen\/Qwen2.5-7B-Instruct<\/code> \u2014 serves an OpenAI-compatible API on port 8000.<\/p>\n<p><code>pip install \"sglang[all]\"<\/code> then <code>python -m sglang.launch_server --model-path Qwen\/Qwen2.5-7B-Instruct<\/code> \u2014 same API shape on port 30000.<\/p>\n<p>Multi-GPU tensor parallelism is <code>--tensor-parallel-size 2<\/code> in vLLM and <code>--tp 2<\/code> in SGLang. Both pull weights straight from Hugging Face. For picking the card itself, see the guide to the <a href=\"https:\/\/convly.ai\/best-gpus-for-local-llms-2026\/\">best GPUs for local LLMs<\/a> and check individual model requirements in the <a href=\"https:\/\/convly.ai\/models\/\">models database<\/a>.<\/p>\n<p>Where friction differs: vLLM&#8217;s documentation, Kubernetes tooling, and community answers are simply more numerous \u2014 obscure errors are more likely to have a solved GitHub issue. SGLang&#8217;s installs are occasionally pickier about CUDA\/PyTorch version combinations; the Docker image is the low-friction path.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Platform_Support\"><\/span>Platform Support<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<h3>Linux<\/h3>\n<p>The only first-class platform for both. NVIDIA GPUs with a recent CUDA-capable driver are the mainline path; AMD ROCm works on both with supported cards. Use the official Docker images for the least version pain.<\/p>\n<h3>Windows<\/h3>\n<p>Neither engine supports Windows natively. Both run under <strong>WSL2<\/strong> with NVIDIA&#8217;s WSL CUDA driver, and that setup is fine for development. For production, use a real Linux host. If you just want a local model on a Windows desktop rather than a serving endpoint, <a href=\"https:\/\/convly.ai\/what-is-ollama-complete-guide-2026\/\">Ollama<\/a> is the simpler tool.<\/p>\n<h3>macOS<\/h3>\n<p>No GPU serving on Apple Silicon from either project. vLLM can be built from source for CPU-only inference on macOS, but that is a development convenience, not a deployment target; SGLang does not target macOS at all. For Mac-local inference, use Ollama or <a href=\"https:\/\/convly.ai\/lm-studio-complete-guide-2026\/\">LM Studio<\/a>, which use Apple&#8217;s Metal GPU acceleration.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Which_to_Pick_by_Workload\"><\/span>Which to Pick, by Workload<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<ul>\n<li><strong>Chatbots, assistants, agent frameworks<\/strong> \u2014 long system prompts, tools, multi-turn history: <strong>SGLang<\/strong>. This is exactly the traffic RadixAttention was built for.<\/li>\n<li><strong>High-volume structured extraction<\/strong> \u2014 classify\/extract to JSON at scale: <strong>SGLang<\/strong>, for jump-forward decoding.<\/li>\n<li><strong>Batch processing of unique documents<\/strong> \u2014 summarisation, embeddings-adjacent pipelines with little prompt overlap: <strong>vLLM<\/strong>; cache reuse won&#8217;t help, and vLLM&#8217;s tooling is deeper.<\/li>\n<li><strong>Many different models, or non-NVIDIA hardware<\/strong> \u2014 AMD, Intel, TPU, Inferentia, exotic quantised checkpoints: <strong>vLLM<\/strong>, no contest on coverage.<\/li>\n<li><strong>You&#8217;re not sure<\/strong>: start with vLLM, then A\/B SGLang against it with your real request logs. The shared OpenAI API makes the swap a base-URL change.<\/li>\n<\/ul>\n<p>And before committing to either, sanity-check that self-hosting beats just calling an API at your volume \u2014 the <a href=\"https:\/\/convly.ai\/self-hosting-vs-api-calculator\/\">self-hosting vs API break-even calculator<\/a> does that math per model and request load.<\/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 SGLang faster than vLLM?<\/h3>\n<p>On workloads with heavy prefix reuse or structured output, usually yes \u2014 sometimes substantially. On cold-cache, one-off prompts the two are close, and results flip between releases. Benchmark with your own traffic pattern rather than trusting any single published number.<\/p>\n<h3>Can I use the OpenAI Python SDK with both?<\/h3>\n<p>Yes. Both serve an OpenAI-compatible <code>\/v1\/chat\/completions<\/code> endpoint, so pointing the official SDK&#8217;s <code>base_url<\/code> at <code>http:\/\/localhost:8000\/v1<\/code> (vLLM) or <code>http:\/\/localhost:30000\/v1<\/code> (SGLang) works with any placeholder API key. This is what makes A\/B testing them nearly free.<\/p>\n<h3>Doesn&#8217;t vLLM have prefix caching too?<\/h3>\n<p>It does \u2014 automatic prefix caching, on by default in recent versions, reuses KV blocks whose hashed content matches. SGLang&#8217;s radix tree matches at finer granularity and its scheduler actively orders requests to raise the hit rate, which is why SGLang still tends to lead on cache-heavy traffic.<\/p>\n<h3>Which engine supports more models?<\/h3>\n<p>vLLM, clearly \u2014 its supported-architecture list is the longest of any open engine, especially for multimodal and niche models. SGLang covers every major open-weight family and often lands day-one support for flagship releases (its DeepSeek optimisations are notably strong), but the long tail belongs to vLLM. Check what a given model needs in the <a href=\"https:\/\/convly.ai\/vram-requirements-every-major-llm-2026\/\">VRAM requirements guide<\/a>.<\/p>\n<h3>Where do Ollama and llama.cpp fit in?<\/h3>\n<p>Different category. Ollama and LM Studio are single-user local tools optimised for convenience on desktops, including Macs; SGLang and vLLM are high-concurrency server engines optimised for GPU throughput across many simultaneous requests. If you&#8217;re serving one user, use Ollama; if you&#8217;re serving an application, use one of these two.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>vLLM is the safer default: broadest model and hardware support, biggest ecosystem, least deployment friction. Pick SGLang when your traffic [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":2136,"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-2135","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\/2135","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=2135"}],"version-history":[{"count":1,"href":"https:\/\/convly.ai\/es\/wp-json\/wp\/v2\/posts\/2135\/revisions"}],"predecessor-version":[{"id":2137,"href":"https:\/\/convly.ai\/es\/wp-json\/wp\/v2\/posts\/2135\/revisions\/2137"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/convly.ai\/es\/wp-json\/wp\/v2\/media\/2136"}],"wp:attachment":[{"href":"https:\/\/convly.ai\/es\/wp-json\/wp\/v2\/media?parent=2135"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/convly.ai\/es\/wp-json\/wp\/v2\/categories?post=2135"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/convly.ai\/es\/wp-json\/wp\/v2\/tags?post=2135"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}