# Descripción general del Collaboration SDK

> Conoce qué resuelve Univer Collaboration SDK, cómo se componen sus módulos, sus puntos de extensión y las funciones de producto que conserva tu aplicación.

- Human documentation: [https://docs.univer.ai/es-ES/server/collaboration/overview](https://docs.univer.ai/es-ES/server/collaboration/overview)

- Agent Markdown: [https://docs.univer.ai/es-ES/server/collaboration/overview.md](https://docs.univer.ai/es-ES/server/collaboration/overview.md)

- Requested language: `es-ES`

- Content language: `es-ES`

- Documentation version: `1.2.0`

- Source: [collaboration/overview.es-ES.mdx](https://github.com/dream-num/documentation/blob/dev/content/server/collaboration/overview.es-ES.mdx)

---

**Univer Collaboration SDK** es un SDK de colaboración del lado del servidor para el modelo de documentos de Univer. Proporciona transformación operacional (OT[^operational-transformation]), revisiones[^collaboration-revision], instantáneas, sincronización en tiempo real y persistencia para que varios clientes Univer editen la misma Unit autoritativa.

Los desarrolladores lo integran en su aplicación Node.js, conectan la identidad y la autorización mediante Middleware y amplían el registro y otras funciones mediante Middleware o Events. Un Database Adapter conecta por separado los datos colaborativos con la base de datos de la aplicación.

> [!NOTE: No es un producto documental completo]
> Collaboration SDK proporciona el núcleo colaborativo. No proporciona usuarios, roles, jerarquías, uso compartido, espacios de archivos ni flujos de negocio. Tu aplicación sigue siendo responsable de esas funciones y modelos de datos.

## Qué resuelve

Web SDK muestra y edita contenido Sheet, Doc, Slide, Board y Base en el navegador. La edición multiusuario también requiere un servidor autoritativo que cargue el contenido, confirme cambios concurrentes, avance las revisiones y permita que los clientes desconectados recuperen un estado coherente.

Es adecuado para aplicaciones que:

* ya usan Univer para crear un editor y necesitan edición multiusuario en tiempo real;
* quieren alojar los datos colaborativos y elegir su base de datos;
* necesitan conectar sus reglas de identidad, autorización o inquilinos con las operaciones colaborativas;
* necesitan History, Thread Comment o Worktree además de la colaboración básica.

## Un servicio colaborativo completo

```mermaid
flowchart LR
    ClientA["Cliente A<br/>Web SDK + Collaboration Client"]
    ClientB["Cliente B<br/>Web SDK + Collaboration Client"]

    subgraph Server["Servidor de colaboración"]
        direction LR
        Transport["Node Transport"]
        Endpoint["Collaboration Endpoint"]
        Service["Collaboration Service"]
        Adapter["Database Adapter"]

        Transport --> Endpoint --> Service --> Adapter
    end

    Database[(Base de datos)]

    ClientA -->|"HTTP / WebSocket"| Transport
    ClientB -->|"HTTP / WebSocket"| Transport
    Adapter --> Database
```

| Módulo                 | Responsabilidad principal                                                                                   |
| ---------------------- | ----------------------------------------------------------------------------------------------------------- |
| Collaboration Client   | Carga Units, envía conjuntos de cambios y mantiene el estado colaborativo del navegador                     |
| Node Transport         | Recibe tráfico HTTP/WebSocket y ejecuta el middleware de entrada de la aplicación                           |
| `UniverCollabEndpoint` | Implementa el protocolo cliente, Sessions, Rooms, Presence, ACK y difusiones                                |
| `UniverCollabService`  | Gestiona el ciclo de vida de las Units, ejecuta OT y confirma revisiones continuas                          |
| Database Adapter       | Almacena atómicamente instantáneas, conjuntos de cambios, revisiones y estado de idempotencia de los envíos |

## Qué proporciona el SDK

Las funciones principales incluyen:

* creación, carga, eliminación y recuperación de Units Sheet, Doc, Slide, Board y Base;
* instantáneas, conjuntos de cambios, revisiones, OT e idempotencia de los envíos;
* carga de contenido por HTTP y Sessions, Rooms, Presence, ACK y difusiones por WebSocket;
* Middleware en los límites de Transport, Endpoint y Service;
* Events locales al proceso para creación de Units, confirmación de cambios, eliminación y recuperación;
* contratos de Database Adapter Memory, SQLite y personalizados;
* escalado horizontal mediante el despliegue en varios nodos: los nodos cooperan a través de un adaptador pub/sub y un almacén de session tickets compartido, con una implementación sobre Redis incluida.

Una vez que funciona el circuito básico, la aplicación puede añadir historial de versiones, comentarios en hilos, borradores Worktree y conversión de archivos Office en el servidor. Estas funciones tienen sus propios Services, Middleware, Events o Database Adapters.

## Qué corresponde a la aplicación

| Collaboration SDK                          | Aplicación                                                        |
| ------------------------------------------ | ----------------------------------------------------------------- |
| Estado colaborativo de las Units           | Usuarios, inquilinos, jerarquía y relaciones de uso compartido    |
| OT, revisiones e instantáneas              | Inicio de sesión, Sessions y correspondencia de identidades       |
| Sessions, Rooms y Presence de colaboración | Roles, ACL y políticas del producto                               |
| Database Adapters de colaboración          | Archivos, almacenamiento de objetos y bases de datos del producto |
| Puntos de extensión Middleware y Event     | Registro, auditoría, métricas e integraciones externas            |
| Endpoints del protocolo cliente            | API de negocio y flujos como la creación de documentos            |

## Tres puntos de extensión generales

| Punto de extensión | Problemas que resuelve                                                                                                   |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------ |
| Middleware         | Inspecciona o amplía el Context, rechaza solicitudes o registra el procesamiento durante una operación                   |
| Event              | Observa cambios confirmados para actualizar estado derivado dentro del proceso o realizar tareas posteriores no críticas |
| Database Adapter   | Selecciona el almacenamiento e implementa los contratos de atomicidad, CAS e idempotencia                                |

La identidad y la autorización se integran mediante Middleware. Usa Middleware para validar y restringir antes de ejecutar una operación, y Events para registrar cambios o iniciar tareas posteriores una vez confirmado el estado. Ambos pueden servir para registros, trazabilidad de solicitudes, métricas y actualización de estado derivado. Consulta [Middleware y Events](https://docs.univer.ai/es-ES/server/collaboration/middleware-and-events.md) para conocer sus límites de ejecución.

## Por dónde empezar

1. Ejecuta el [inicio rápido](https://docs.univer.ai/es-ES/server/collaboration/quick-start.md) para comprobar el circuito completo en dos navegadores.
2. Lee [Límites y relaciones entre módulos](https://docs.univer.ai/es-ES/server/collaboration/modules.md) para comprender el propósito de cada paquete.
3. Continúa con [Middleware y Events](https://docs.univer.ai/es-ES/server/collaboration/middleware-and-events.md), [Identidad y autorización](https://docs.univer.ai/es-ES/server/collaboration/identity-and-authorization.md) o [Adaptadores de base de datos](https://docs.univer.ai/es-ES/server/collaboration/database-adapters.md), según tu integración.
4. Consulta [Módulos de extensión de colaboración](https://docs.univer.ai/es-ES/server/collaboration/extensions.md) para History, comentarios, Worktree y conversión de archivos.

[^operational-transformation]: La transformación operacional (OT) ajusta operaciones concurrentes creadas sobre distintas revisiones para aplicarlas de forma coherente. Trabaja con las ediciones, sin sustituir todo el documento por la última instantánea recibida.

[^collaboration-revision]: Una revisión identifica una posición en el historial confirmado de una Unit. Un changeset contiene las operaciones de un envío; su confirmación hace avanzar el historial. No es una versión del SDK ni una marca de tiempo.