DeepSeek-OCR: guía práctica con 7 ejemplos reales

DeepSeek-OCR es un nuevo gran modelo visión‑lenguaje que entiende la estructura, interpreta tablas, extrae gráficos e incluso se atreve con matemáticas, memes y varios idiomas.

En esta guía, pongo a prueba DeepSeek-OCR en tareas reales de principio a fin: desde notas manuscritas hasta gráficos complejos, memes y documentos multilingües. Veremos:

• Extracción de gráficos y tablas
• Análisis de química y fórmulas
• Reconocimiento de texto manuscrito
• Ecuaciones y salida en Markdown
• OCR para memes e imágenes sociales
• Comprensión de documentos multilingües

Al final verás dónde brilla DeepSeek-OCR y en qué sigue teniendo margen de mejora. Si estás evaluando OCR de código abierto, merece la pena ver estos experimentos antes de decidir tu pipeline. Te recomiendo también nuestro tutorial de DeepSeek V3.2-Speciale.

¿Qué es DeepSeek-OCR?

DeepSeek-OCR es un modelo visión‑lenguaje abierto de 3B parámetros entrenado para comprensión de documentos. Aprovecha la compresión óptica de contexto mapeando grandes contextos visuales 2D en tokens de visión comprimidos, lo que le permite procesar documentos muy extensos con eficiencia.

Entre sus funciones clave destacan:

• Lectura de grandes documentos escaneados, recibos, facturas, artículos científicos, etc.
• Análisis de tablas, gráficos y figuras geométricas.
• Gestión de texto multilingüe y manuscrito.

¿Cómo funciona DeepSeek-OCR?

DeepSeek-OCR está diseñado para manejar una gran variedad de imágenes de documentos, desde gráficos y tablas hasta escritura a mano, matemáticas y texto multilingüe. En lugar de tratar imágenes y texto como dominios separados, utiliza la modalidad visual como motor de compresión para texto largo, permitiendo a los modelos de lenguaje grandes (LLMs) procesar mucha más información con drásticamente menos tokens. Veamos su arquitectura y qué la hace diferente:

El pipeline de extremo a extremo: del codificador al decodificador

A alto nivel, DeepSeek-OCR consta de dos componentes principales:

• DeepEncoder (tokenizador y compresor visual)
• DeepSeek-3B MoE Decoder (generador de texto)

Fuente: DeepSeek-OCR: Contexts Optical Compression

1. Preprocesamiento de la imagen de entrada: El pipeline comienza con una imagen de documento, como un contrato escaneado, una nota manuscrita, una tabla financiera, etc. Esta imagen se divide en una cuadrícula de parches de 16x16 píxeles como las unidades visuales mínimas que el modelo entiende.

2. DeepEncoder: DeepEncoder es un motor visual multietapa diseñado para equilibrar resolución, uso de memoria y compresión de información. Opera en tres etapas principales:

• SAM (Segment Anything Model, 80M params): gestiona la atención local analizando parches pequeños y solapados para capturar detalles finos y maquetación.
• Compresor convolucional (reducción 16x): reduce drásticamente el número de tokens visuales comprimiendo rasgos locales, de modo que lleguen menos tokens a la costosa etapa de atención global.
• CLIP ViT: transformer visual (300M params) que aplica atención global para entender la estructura y el contexto general del documento, actuando como capa de embeddings para los tokens comprimidos.

3. De tokens visuales a texto: El decodificador MoE comprime los tokens visuales que se envían al decodificador DeepSeek-3B MoE (Mixture-of-Experts) para una inferencia eficiente, activando solo los expertos más relevantes por muestra y reduciendo el coste computacional sin perder precisión.

4. Flexibilidad guiada por prompts: El sistema dirige el formato de salida (Markdown, tablas HTML, fórmulas químicas SMILES, maquetaciones multilingües, etc.) simplemente cambiando el prompt, igual que con los LLMs.

DeepSeek-OCR demuestra que una sola imagen de documento puede "comprimirse" hasta en 1/10 de los tokens necesarios para texto plano, sin pérdida sustancial de precisión. 

Demo de DeepSeek OCR: aplicación con Gradio

En esta sección, montaremos una aplicación web completa con Gradio para ejecutar OCR con DeepSeek-OCR directamente en tu navegador o en Google Colab. Con unos pocos pasos, podrás subir imágenes de gráficos, tablas, notas manuscritas, memes, matemáticas o texto multilingüe y obtener una salida estructurada con cajas delimitadoras.

Paso 1: requisitos previos

Antes de empezar, asegúrate de cumplir estos requisitos:

!pip install -q "transformers==4.46.3" "tokenizers==0.20.3" einops addict easydict pillow gradioCon la tecnología de

El comando anterior instala todas las librerías de Python necesarias para DeepSeek-OCR y Gradio, incluidas las versiones compatibles más recientes de transformers, tokenizers, procesamiento de imágenes (pillow) y el kit de UI de Gradio. 

Nota: este código se ejecuta en una GPU L4 con RAM alta en Google Colab.

Paso 2: imports

Ya tenemos todas las dependencias instaladas. Ahora configuramos los imports.

import os, time, torch, gradio as gr
from PIL import Image
from transformers import AutoModel, AutoTokenizer
from datetime import datetime
import random
import stringCon la tecnología de

Importamos los módulos esenciales de Python para E/S de ficheros, inferencia del modelo (torch), creación de la interfaz (gradio), manejo de imágenes (PIL) y utilidades para gestionar rutas y IDs aleatorios de ejecución.

Paso 3: cargar el modelo

Con todas las librerías instaladas, ya puedes cargar el modelo DeepSeek-OCR desde Hugging Face. Sin embargo, para acceder a ciertos modelos es necesario autenticarse con un token de acceso de Hugging Face.

Así configuras tu token de acceso de Hugging Face en Google Colab:

• Añade un secreto en Colab: en tu cuaderno de Google Colab, haz clic en el icono de la llave (“Secrets”) en la barra lateral izquierda y selecciona “Add a Secret”.
• Crea un token en Hugging Face: inicia sesión en tu cuenta de Hugging Face, ve a los ajustes y busca la sección “Access Tokens”. Haz clic en “Create new token”, elige el rol adecuado (normalmente “Read”) y genera tu token.
• Copia y pega el token: copia tu nuevo token de acceso y pégalo en el campo “Add a Secret” de Colab. Esto permite que tu cuaderno acceda de forma segura al modelo DeepSeek-OCR.

¡Listo para autenticarte y cargar el modelo!

model_id = "deepseek-ai/DeepSeek-OCR"
tok = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
if tok.pad_token is None and tok.eos_token is not None:
    tok.pad_token = tok.eos_token
model = AutoModel.from_pretrained(
    model_id,
    trust_remote_code=True,
    use_safetensors=True,
    attn_implementation="eager"
).to(dtype=torch.bfloat16, device="cuda").eval()Con la tecnología de

El código anterior carga el modelo oficial DeepSeek-OCR y su tokenizer directamente desde Hugging Face. Asegura la compatibilidad del tokenizer estableciendo el token de padding y carga el modelo en formato bfloat16.

Paso 4: función de ayuda

Con el modelo listo, creamos un directorio nuevo para cada salida y mantener organizadas todas las ejecuciones de OCR. Así nos aseguramos de que el texto extraído, las visualizaciones de cajas y los logs se guarden sin sobreescribir resultados anteriores.

def new_run_dir(base="/content/runs"):
    os.makedirs(base, exist_ok=True)
    ts = datetime.now().strftime("%Y%m%d-%H%M%S")
    rid = ''.join(random.choices(string.ascii_lowercase + string.digits, k=5))
    path = os.path.join(base, f"run_{ts}_{rid}")
    os.makedirs(path)
    return pathCon la tecnología de

La función new_run_dir crea un directorio de salida único por ejecución, basado en la marca temporal y un sufijo aleatorio. Así evitas sobrescribir resultados y organizas los ficheros para su revisión o depuración.

Paso 5: manejador de OCR

Este paso es el motor principal de la app de Gradio para DeepSeek-OCR. Empieza convirtiendo la imagen subida al formato correcto y redimensionándola si el archivo es demasiado grande. En cada ejecución, guarda todas las salidas en una carpeta nueva.

def gr_ocr(image, mode, custom_prompt, base_size, image_size, crop_mode):
    img = image.convert("RGB")
    if max(img.size) > 2000:
        s = 2000 / max(img.size)
        img = img.resize((int(img.width*s), int(img.height*s)), Image.LANCZOS)
    run_dir = new_run_dir()
    img_path_proc = os.path.join(run_dir, "input.png")
    img.save(img_path_proc, optimize=True)
    if mode == "Custom Prompt" and custom_prompt.strip():
        prompt = custom_prompt.strip()
    else:
        prompt = DEMO_MODES[mode]["prompt"]
    t0 = time.time()
    try:
        with torch.inference_mode():
            _ = model.infer(
                tok,
                prompt=prompt,
                image_file=img_path_proc,
                output_path=run_dir,
                base_size=base_size,
                image_size=image_size,
                crop_mode=crop_mode,
                save_results=True,
                test_compress=True
            )
    except ZeroDivisionError:
        print(" [Patched] Division by zero in compression ratio (valid_img_tokens==0). Ignored.")
    dt = time.time() - t0
    result_file = os.path.join(run_dir, "result.mmd")
    if not os.path.exists(result_file):
        result_file = os.path.join(run_dir, "result.txt")
    result = "[No text extracted]"
    if os.path.exists(result_file):
        with open(result_file, "r", encoding="utf-8") as f:
            result = f.read().strip() or "[No text extracted]"
    boxed_path = os.path.join(run_dir, "result_with_boxes.jpg")
    boxed_img = Image.open(boxed_path) if os.path.exists(boxed_path) else None
    stats = f"""
**{dt:.1f}s** | Image: {img.size[0]}×{img.size[1]} px  
**Output directory:** {run_dir}  
"""
    return result, stats, boxed_imgCon la tecnología de

La función gr_ocr encapsula el preprocesamiento, la inferencia y el posprocesado para la aplicación de Gradio de DeepSeek-OCR. Realiza lo siguiente:

• Estandarización y preprocesado de la imagen: convierte cualquier imagen a espacio de color RGB para asegurar compatibilidad. Si supera 2000 px en su mayor dimensión, la redimensiona proporcionalmente para evitar desbordes de memoria en la GPU.
• Gestión del directorio de ejecución: cada ejecución de OCR se aísla en un directorio único. Esto facilita la trazabilidad, esencial para procesos por lotes, depuración y reproducibilidad.
• Inferencia eficiente del modelo: invoca el modelo dentro de torch.inference_mode() para no calcular gradientes, reduciendo memoria y acelerando la inferencia.
• Gestión de bordes y errores: maneja excepciones como ZeroDivisionError en casos raros de compresión de tokens, sin interrumpir la experiencia del usuario.
• Agregación de resultados y visualización: tras la inferencia, carga el texto extraído y una imagen con superposición de cajas delimitadoras para facilitar la revisión.
• Integración con la UI: devuelve una tupla con la salida del OCR, estadísticas de proceso y la imagen anotada para integrarse sin fricciones en Gradio.

Pasemos a la interfaz interactiva y veamos DeepSeek-OCR en acción.

Paso 6: UI en Gradio

En el último paso, definimos una interfaz interactiva en Gradio para DeepSeek-OCR, que permite subir imágenes, elegir distintos modos de extracción, ajustar parámetros avanzados y ver resultados en una única UI web.

DEMO_MODES = {
    "Document ➔ Markdown": {
        "prompt": "<image>\n<|grounding|>Convert the document to markdown.",
        "desc": "Extracts full document text as Markdown, preserving structure (headings, tables, lists, etc.).",
        "base_size": 1024, "image_size": 640, "crop_mode": False
    },
    "Chart Deep Parsing": {
        "prompt": "<image>\nParse all charts and tables. Extract data as HTML tables.",
        "desc": "Extracts tabular/chart data into HTML tables.",
        "base_size": 1024, "image_size": 640, "crop_mode": False
    },
    "Chemical Formula Recognition": {
        "prompt": "<image>\nExtract all chemical formulas and SMILES.",
        "desc": "Extracts chemical structures and formulae.",
        "base_size": 1024, "image_size": 768, "crop_mode": False
    },
    "Geometry Parsing": {
        "prompt": "<image>\nExtract all geometric figures and their measurements.",
        "desc": "Parses diagrams and extracts geometric data.",
        "base_size": 1024, "image_size": 768, "crop_mode": False
    },
    "Plain Text Extraction": {
        "prompt": "<image>\nFree OCR.",
        "desc": "Fast, plain text OCR of the image.",
        "base_size": 768, "image_size": 512, "crop_mode": False
    },
    "Multilingual Document": {
        "prompt": "<image>\n<|grounding|>Extract text. Preserve all languages and structure.",
        "desc": "Extracts multi-language content, preserves structure.",
        "base_size": 1024, "image_size": 640, "crop_mode": False
    },
    "Custom Prompt": {
        "prompt": "",
        "desc": "Provide your own custom prompt for flexible OCR or parsing.",
        "base_size": 1024, "image_size": 640, "crop_mode": False
    }
}
with gr.Blocks(theme=gr.themes.Soft()) as demo:
    gr.Markdown("""
    <div style="text-align:center;">
        <h1>DeepSeek-OCR Demo</h1>
    </div>
    """)
    with gr.Row():
        with gr.Column():
            gr.Markdown("### Input")
            image_input = gr.Image(type="pil", label="Upload Document/Image", height=350)
            gr.Markdown("#### Demo Modes (From Paper)")
            mode = gr.Radio(
                choices=list(DEMO_MODES.keys()), value="Document to Markdown", label="Select Capability to Test"
            )
            desc = gr.Markdown(DEMO_MODES["Document to Markdown"]["desc"])
            custom_prompt = gr.Textbox(label="Custom Prompt", visible=False)
            with gr.Accordion("Advanced Settings", open=False):
                base_size = gr.Slider(512, 1280, value=DEMO_MODES["Document to Markdown"]["base_size"], step=64, label="Base Size")
                image_size = gr.Slider(512, 1280, value=DEMO_MODES["Document to Markdown"]["image_size"], step=64, label="Image Size")
                crop_mode = gr.Checkbox(value=DEMO_MODES["Document to Markdown"]["crop_mode"], label="Dynamic Resolution (Crop Mode)")
            process_btn = gr.Button("Process Image", variant="primary")
        with gr.Column():
            gr.Markdown("### Results")
            ocr_output = gr.Textbox(label="Extracted Content", lines=22, show_copy_button=True)
            status_out = gr.Markdown("_Process an image to see stats and output dir_")
            boxed_output = gr.Image(label="Result with Bounding Boxes", type="pil")
    def update_mode(selected):
        d = DEMO_MODES[selected]
        return d["desc"], gr.update(visible=selected=="Custom Prompt"), d["base_size"], d["image_size"], d["crop_mode"]
    mode.change(update_mode, inputs=mode,
                outputs=[desc, custom_prompt, base_size, image_size, crop_mode])
    process_btn.click(
        gr_ocr,
        inputs=[image_input, mode, custom_prompt, base_size, image_size, crop_mode],
        outputs=[ocr_output, status_out, boxed_output]
    )
demo.launch(share=True, debug=True)Con la tecnología de

Desglosemos el código por secciones:

• Modos de demo y prompts: el diccionario DEMO_MODES reúne las principales capacidades de OCR de DeepSeek-OCR, como "Document to Markdown", "Chart Deep Parsing", "Chemical Formula Recognition" y más. Cada modo incluye un prompt por defecto, descripción y parámetros recomendados de procesamiento de imagen, lo que permite cambiar de tarea sobre la marcha.
• Arquitectura por bloques: la UI se construye con la API de alto nivel Blocks de Gradio. La interfaz se divide en dos columnas: un panel de entrada para subir la imagen, elegir el modo de OCR y ajustar parámetros como el tamaño de imagen o el modo de recorte; y un panel de salida que muestra el contenido extraído, estadísticas de inferencia y una imagen anotada con cajas sobre las regiones detectadas.
• Controles dinámicos de la UI: la app incluye radios, deslizadores, casillas y cuadros de texto que se actualizan automáticamente según la entrada del usuario y el modo elegido, mejorando la usabilidad y minimizando la configuración manual.
• Lanzador de inferencia y resultados: al hacer clic en Process Image se llama al manejador principal gr_ocr, pasando todas las selecciones actuales de la UI. Las salidas se renderizan inmediatamente en el panel de resultados.

Nota: puede que tengas que reiniciar la sesión en Google Colab si sigue devolviendo la salida del input anterior.

Con la aplicación de Gradio lista, pongamos a prueba DeepSeek-OCR con una serie de ejemplos prácticos.

Ejemplo 1 de la app DeepSeek OCR: Chart Deep Parsing

Dentro de la demo de Gradio, quise comprobar qué tal extraía el modelo datos tabulares a partir de gráficos. Esto sigue siendo difícil para la mayoría de modelos de visión y OCR.

Probé dos casos clásicos:

• Un gráfico de barras estilo Statista y
• un gráfico de análisis técnico complejo lleno de señales “BUY/SELL” y superposiciones numéricas

DeepSeek-OCR devolvió una tabla HTML para cada gráfico, con celdas que correspondían a categorías, valores y etiquetas detectadas en la imagen.

Lo que funcionó: capturó todo el texto visible y la estructura del gráfico, y la salida en formato de tabla HTML es utilizable por máquina y mantiene la lógica tabular. Incluso procesó gráficos financieros complejos intentando tabular cada número y etiqueta.

Donde flojea: la salida es muy verbosa, con multitud de etiquetas <td> y <tr>, lo que dificulta su lectura rápida. En gráficos complejos, a veces duplica entradas o pierde la estructura visual de alto nivel, generando tablas abrumadoras con señales “BUY”/“SELL” repetidas y valores.

En flujos reales, conviene posprocesar el HTML para legibilidad o importarlo en Excel o Pandas.

El análisis de gráficos de DeepSeek-OCR es una función inteligente de “digitalización de gráficos”, pero la salida cargada de HTML es más adecuada para pipelines de datos posteriores o más parsing, no para una revisión humana rápida.

Ejemplo 2: extracción de fórmulas químicas

En la siguiente prueba, quería ver cómo manejaba DeepSeek-OCR la extracción de información química a partir de imágenes estructuradas. El modo químico está pensado para convertir tanto datos químicos tabulares como estructuras moleculares gráficas en formatos legibles por máquina, como tablas HTML y notación SMILES.

Subí dos tipos de imágenes para este experimento, y esto fue lo que observé:

• Extracción de fórmulas en texto: el modelo transcribió con precisión nombres químicos y sus fórmulas moleculares (como “Glucose: C₆H₁₂O₆”, “Butane: C₄H₁₀”). No obstante, la salida venía como código de tabla HTML en crudo que, aunque estructurado, cuesta interpretar de un vistazo. La conversión de imagen a tabla fue rápida y razonablemente precisa para texto plano.

• Reconocimiento de estructuras moleculares: para imágenes con diagramas químicos, DeepSeek-OCR intentó extraer las cadenas SMILES correspondientes. Por ejemplo, generó una salida SMILES para etano y propano. Aunque identificó que eran estructuras químicas, las cadenas SMILES generadas no siempre eran químicamente válidas, lo que evidencia limitaciones al interpretar imágenes moleculares más complejas.

En conjunto, la capacidad de extracción química ofrece una vía rápida para digitalizar datos químicos y probar el reconocimiento de estructuras, pero necesita más refinamiento para un parsing químico fiable, sobre todo en estructuras complejas.

Ejemplo 3: OCR de texto manuscrito

Después, quise comprobar cómo maneja DeepSeek-OCR notas manuscritas, un reto clásico para el OCR, especialmente con caligrafías estilizadas o tamaños variables. 

Subí una imagen con una lista manuscrita de química, con nombres de compuestos en papel pautado. Tras el proceso, el modo Document to Markdown extrajo el texto y conservó sorprendentemente bien la estructura. Reconoció el encabezado y listó cada compuesto en su propia línea, tal como aparecía en la imagen. Las cajas delimitadoras confirmaron visualmente que el modelo identificó bien cada línea y separó los bloques de texto.

Este resultado demuestra la capacidad del modelo para transcribir contenido manuscrito a texto digital. Puede que se pierdan pequeños detalles de formato, pero la extracción global fue muy precisa en este ejemplo.

Ejemplo 4: extracción de ecuaciones

Otra prueba estándar para el OCR es leer e interpretar correctamente ecuaciones matemáticas en notación de libro de texto. Para este experimento, subí una imagen con ecuaciones complejas en tipografías estilo LaTeX para evaluar si el modelo no solo las detecta, sino que también las extrae y formatea con precisión.

DeepSeek-OCR detectó correctamente las cuatro ecuaciones de la imagen y las extrajo como cadenas LaTeX. La salida estaba bien estructurada, con cada ecuación en su propia línea en formato LaTeX estándar. 

Las cajas delimitadoras se superpusieron en la imagen original de forma correcta (aproximada), lo que demuestra que el modelo localiza y segmenta con precisión expresiones matemáticas individuales.

Destaca que el contenido extraído mantiene la estructura matemática con comandos como \frac para fracciones y el formato apropiado de variables, lo que hace que el resultado se pueda reutilizar directamente en documentación. 

Ejemplo 5: extracción de tablas

Una de las tareas de OCR más comunes y valiosas es extraer datos tabulares de imágenes de documentos, especialmente con informes escaneados, artículos científicos o datasets. Para evaluar a DeepSeek-OCR en este terreno, subí una imagen con una tabla estructurada de comparación económica entre varios países.

Tras seleccionar el modo "Chart Deep Parsing" y procesar la imagen, DeepSeek-OCR intentó convertir la tabla visual en una estructura de tabla HTML. El contenido extraído (a la derecha) contiene una serie de etiquetas <table> y <td> que mapean filas y columnas como texto plano. La salida con cajas confirmó además que el modelo identificó y segmentó correctamente la región principal de la tabla.

El modelo muestra una extracción fiable para tablas sencillas, aunque puede requerir posprocesado porque el formato (HTML en crudo) no es el más cómodo para una revisión rápida o análisis de datos posterior.

Ejemplo 6: OCR en memes

En este ejemplo probé cómo maneja el modelo la extracción de texto en memes populares. Es un escenario real en el que el texto suele superponerse a fondos complejos, usa tipografías variadas y no sigue estructuras de documento.

Subí un meme clásico con texto grande, blanco y en mayúsculas sobre una escena de película (Leonardo DiCaprio en Django Unchained) y ejecuté el modo de extracción Document to Markdown.

Fuente: Media.io

El resultado de OCR fue sorprendentemente robusto: capturó todas las palabras relevantes en el orden correcto, sin errores ortográficos ni omisiones pese al fondo complejo. 

Aunque no hay marcado estructural, la extracción es muy útil para tareas posteriores como análisis de sentimiento en memes, moderación de contenido o búsqueda textual de memes.

Ejemplo 7: OCR multilingüe

Una de las fortalezas de DeepSeek-OCR es su soporte para extracción de texto multilingüe, especialmente útil en documentos o imágenes que mezclan idiomas.

Probé esta capacidad con varias muestras, incluyendo una señal de calle real con texto en chino y un ejemplo sintético con frases en chino, japonés y coreano.

Fuente: DeepSeek OCR en Hugging Face

Al procesar estas muestras multilingües, el modo document-to-Markdown detectó y extrajo con precisión escrituras no inglesas. En la foto de la calle, identificó y devolvió todo el párrafo en chino. 

En el ejemplo mixto, separó y etiquetó correctamente las secciones en chino, japonés y coreano, preservando su formato y bloques de texto. Las superposiciones con cajas también mostraron una detección precisa de cada región de texto por idioma.

Eso sí, dos advertencias importantes:

• Velocidad de procesamiento: el OCR multilingüe es notablemente más lento que el inglés o la extracción de tablas. En mis pruebas tardó bastante más, probablemente por la mayor complejidad en la detección y decodificación de escrituras.
• Errores ocasionales: a veces la salida incluye tokens redundantes o texto con formato incorrecto.

Pese a estos pequeños fallos, DeepSeek-OCR ofrece un OCR multilingüe sólido que maneja con fiabilidad escrituras mixtas y fotos reales.

Conclusiones sobre DeepSeek-OCR

DeepSeek-OCR reduce la distancia entre el OCR clásico y los LLMs multimodales modernos. Su mayor baza es la versatilidad: un único pipeline que lee documentos escaneados, extrae tablas y gráficos complejos, entiende ecuaciones y estructuras químicas, y además funciona con memes, escritura a mano y decenas de idiomas.

Ahora bien, no es perfecto. La salida de gráficos y tablas puede ser excesivamente verbosa, el reconocimiento de estructuras químicas a veces se queda corto y el procesamiento multilingüe puede ser visiblemente lento. Los diseños visuales complejos pueden requerir posprocesado para su uso directo.

Pero para investigación, entornos académicos, prototipado rápido y cualquiera que necesite un OCR avanzado más allá del texto plano, DeepSeek-OCR ya se siente como una mejora importante frente a herramientas heredadas. 

Si quieres profundizar en el ecosistema DeepSeek, te recomiendo el curso Working with DeepSeek in Python.