cove-book-forge-mcp

Convierte un PDF o EPUB en conocimiento reutilizable, no en otro chat de un solo uso.

cove-book-forge-mcp es un servidor MCP local-first y de código abierto que transforma libros en análisis estructurado para IA, notas de Obsidian, Skills por capítulo o una única Skill de Agente completa e instalable. Analiza un capítulo una vez, reutiliza el resultado en distintos formatos de salida y lleva el conocimiento terminado a Codex, Claude Code u otro sistema de lectura compatible con MCP.

Qué puedes hacer

• Forjar un libro completo en una única Skill de Agente. Importa un PDF o EPUB, analiza cada capítulo mediante un trabajo reanudable y publica una Skill con divulgación progresiva que un agente puede usar sin cargar el libro completo en cada prompt.

• Elegir el formato de salida adecuado para cada capítulo. Envía el mismo capítulo analizado a una base de conocimiento de Obsidian protegida o conviértelo en una Skill de capítulo reutilizable.

• Analizar una vez en lugar de pagar dos veces. Huellas estables almacenan en caché el análisis validado de capítulos, de modo que los flujos de Obsidian, Skill de capítulo y libro completo reutilizan resultados coincidentes sin llamadas adicionales al modelo.

• Instalar Skills donde ya trabajas. Las Skills generadas se pueden instalar para Codex, Claude Code o un directorio genérico convencional de Agent Skills.

• Usar tu modelo preferido. Los adaptadores integrados cubren OpenAI, DeepSeek y otros endpoints compatibles con OpenAI, así como Anthropic; las aplicaciones pueden inyectar un proveedor personalizado sin modificar la forja.

• Conservar u omitir la biblioteca integrada. Almacena copias gestionadas localmente, conserva referencias verificadas, o deja que un sistema de lectura existente siga siendo la autoridad y envía instantáneas completas de capítulos a través del límite público.

• Construir cualquier experiencia de lectura a su alrededor. El MCP expone libros, capítulos, análisis, salidas, trabajos de libro completo, controles, estado y Skills generadas a través de stdio o Streamable HTTP solo de bucle local.

Related MCP server: ebook-mcp

Del libro a la inteligencia reutilizable

PDF / EPUB / existing reading system
                 │
                 ▼
       normalized chapters
                 │
                 ▼
    validated AI analysis + cache
          ┌──────┼───────────┐
          ▼      ▼           ▼
     Obsidian  chapter     complete-book
       notes    Skill          Skill
          └──────┼───────────┘
                 ▼
       Codex / Claude Code /
       any compatible client

Por qué es diferente

Esto es más que un analizador de documentos o un prompt que resume un libro una sola vez. La forja proporciona un límite de aplicación reutilizable: capítulos deterministas, análisis validado por esquema, caché persistente, salidas gestionadas atómicas y trabajos de libro completo reiniciables. Es útil tanto como backend MCP listo para usar como infraestructura para desarrolladores que construyen su propia interfaz de lectura.

Úsalo cuando quieras:

• convertir un libro que quizá no leas capítulo a capítulo en una Skill completa reutilizable;

• seguir leyendo en tu aplicación existente mientras delegas el análisis y la publicación;

• construir una interfaz de lectura con IA sin reconstruir desde cero la ingesta, el caché, los trabajos, la salida de Obsidian y la generación de Agent Skills; o

• poner el conocimiento derivado de libros a disposición de varios agentes sin pegar repetidamente el texto fuente en el chat.

Qué incluye

La versión actual implementa ingesta de EPUB válidos según estándares, ingesta de PDF con capa de texto, una biblioteca SQLite local opcional, caché externo de instantáneas de capítulos, adaptadores de proveedores de modelos, análisis de capítulos validado y reutilizable, publicación protegida en Obsidian, forjado persistente de Agent Skills de libro completo y herramientas y recursos MCP a través de stdio o Streamable HTTP de bucle local.

El repositorio es independiente del código privado de Cove/栖渡 y, a propósito, no prescribe una interfaz de lectura. Los PDF escaneados aún requieren un paso de OCR externo; el núcleo falla explícitamente en lugar de subir contenido o adivinarlo silenciosamente.

Entrada admitida y límites de seguridad

EPUB

• Se admiten archivos EPUB 2/3 válidos según estándares.

• El orden de lectura proviene del spine del OPF, no de los nombres de archivo ni del orden de los miembros del ZIP. Las etiquetas de navegación/NCX del EPUB proporcionan los títulos de los capítulos cuando están disponibles.

• Cada miembro del ZIP se preinspecciona antes de leer el contenido del libro. Las rutas absolutas, el ascenso a directorios padre, las rutas con barras invertidas, las entradas cifradas, los enlaces simbólicos del archivo, los archivos anidados y las violaciones del límite de expansión configurado se rechazan.

PDF

• Los PDF deben contener una capa de texto significativa. El texto de las páginas permanece en el orden físico de las páginas y los rangos de capítulos deterministas mantienen direccionable el libro normalizado.

• Los PDF escaneados o solo de imagen fallan explícitamente con OCR_REQUIRED. El núcleo no descarga un motor de OCR, no llama a un servicio remoto ni invoca silenciosamente una alternativa de OCR.

• Los PDF cifrados y malformados fallan con errores cerrados y seguros para rutas.

Los límites de ingesta predeterminados son:

Las fuentes se someten a huella antes y después de la extracción. Una fuente que cambia durante el análisis falla con SOURCE_CHANGED y no se persiste parcialmente.

Biblioteca local opcional

La caché local reside en el library.data_dir configurado y usa library.sqlite3. La inicialización y la migración del esquema son explícitas y locales.

• COPY almacena una copia verificada dentro del directorio de datos de la biblioteca. La fuente original puede moverse o desaparecer más tarde sin afectar a la copia gestionada.

• REFERENCE almacena la ruta de la fuente resuelta y su huella sin copiar el archivo. Si la fuente cambia o desaparece, source_available pasa a False; los capítulos ya normalizados siguen siendo legibles.

• Establecer library.enabled: false desactiva la importación de archivos gestionados. Una ChapterSnapshot externa completa y estable aún puede insertarse o actualizarse en la caché local opcional y sobrevive a una nueva instancia del servicio de biblioteca. El sistema externo sigue siendo la autoridad.

Importación gestionada con API públicas

from pathlib import Path

from cove_book_forge.config import AppConfig
from cove_book_forge.contracts import ImportMode
from cove_book_forge.library import create_book_library

data_dir = Path("/absolute/path/to/local-library")
config = AppConfig.model_validate(
    {
        "library": {"enabled": True, "data_dir": data_dir},
        "model": {"provider": "unused-local", "model": "unused-local"},
    }
)
library = create_book_library(config)
imported = library.import_book(Path("/absolute/path/to/book.epub"), ImportMode.COPY)

stored = library.get_book(imported.book)
first_chapter = library.get_chapter(imported.book, 0)
print(stored.metadata.title, first_chapter.title)

Usa ImportMode.REFERENCE para conservar una referencia en lugar de una copia gestionada. list_books(), get_book() y get_chapter() leen los mismos contratos normalizados después de construir otro servicio para el mismo directorio de datos.

Inserción o actualización de instantáneas externas con la importación gestionada desactivada

from pathlib import Path

from cove_book_forge.config import AppConfig
from cove_book_forge.contracts import BookMetadata, ChapterContent, ChapterSnapshot
from cove_book_forge.library import create_book_library

config = AppConfig.model_validate(
    {
        "library": {
            "enabled": False,
            "data_dir": Path("/absolute/path/to/optional-external-cache"),
        },
        "model": {"provider": "unused-local", "model": "unused-local"},
    }
)
library = create_book_library(config)
book = library.upsert_chapter_snapshot(
    ChapterSnapshot(
        source_system="my-reader",
        external_book_id="stable-book-id",
        book=BookMetadata(title="External Book", total_chapters=1),
        chapter=ChapterContent(
            index=0,
            title="Chapter 1",
            content="Complete normalized chapter text.",
            source_locator="my-reader:chapter:0",
        ),
    )
)
print(library.get_chapter(book, 0).content)

Análisis de capítulos reutilizable

ChapterAnalyzer convierte una ChapterSnapshot normalizada en el contrato público estricto ChapterAnalysis mediante un ModelProvider asíncrono inyectado. Valida cada respuesta estructurada contra el esquema del contrato y permite como máximo una generación adicional cuando el Provider informa de una salida de modelo no válida o el objeto devuelto no valida. Los fallos de autenticación, límite de velocidad, disponibilidad y configuración no se reparan y nunca activan un Provider alternativo.

El analizador calcula una huella estable sobre el título/cuerpo del capítulo normalizado, los destacados, las notas, las anotaciones, las reflexiones, la configuración de análisis, las versiones de prompt y generador, y el esquema de ChapterAnalysis. Una entrada de caché persistente coincidente devuelve el resultado sin llamadas al Provider, incluso después de recrear tanto la biblioteca como el analizador. La identidad de Provider/modelo/base se ignora por defecto y puede incluirse explícitamente con analysis.include_provider_in_fingerprint: true. Los nombres y valores de claves de API nunca entran en la huella.

Los capítulos largos se dividen sin pérdida en límites compatibles con Markdown. Los fragmentos ordenados contienen solo el contenido del capítulo; el código entre comillas invertidas y las tablas de Markdown permanecen atómicos, incluso cuando un bloque supera el límite configurado. Cada fragmento recibe un análisis validado, seguido de exactamente una fusión final que recibe los análisis de fragmentos validados y los destacados, notas, anotaciones y reflexiones del capítulo. El cuerpo completo no se repite en la fusión, y solo el análisis fusionado final se almacena en caché bajo la huella completa del capítulo.

from cove_book_forge.analysis import ChapterAnalyzer

analyzer = ChapterAnalyzer(
    provider,
    library,
    config.analysis,
    config.model,
)
analyzed = await analyzer.analyze(snapshot)
print(analyzed.analysis.core_idea, analyzed.cache_hit)

El mismo AnalyzedChapter alimenta ambas salidas implementadas sin reanálisis. Un sistema de lectura existente proporciona la ChapterSnapshot completa; su caché local proporciona el AnalyzedChapter coincidente, de modo que una publicación de Skill no vuelve a llamar al Provider.

Forjado persistente de Skills de libro completo

WholeBookForge acepta un book_id de biblioteca gestionada o una secuencia ordenada completa de ChapterSnapshot externas. La planificación crea un ForgePlan de 30 minutos sin secretos vinculado a cada huella de análisis de capítulo, al Provider/modelo seleccionado, a las versiones de prompt y generador y a la configuración de salida de la Skill. Su estimación informa de tokens y llamadas al modelo solo para análisis no almacenados en caché; no inventa precios.

Iniciar un plan requiere confirmación explícita y una clave de idempotencia. Un controlador posee la Skill de un libro a la vez. El diario SQLite persistente registra planes, trabajos y puntos de control de publicación de capítulos. Cada capítulo se analiza mediante ChapterAnalyzer y se publica mediante AgentSkillOutput, de modo que los aciertos de caché no realizan llamadas al modelo y la Skill final contiene el conjunto completo de capítulos. La pausa y la cancelación surten efecto en los límites de los capítulos; la cancelación conserva los capítulos ya publicados. Los trabajos interrumpidos o fallidos pueden reanudarse/reintentarse sin repetir los puntos de control completados, incluso después de reiniciar el proceso.

Servidor MCP

Instala el proyecto e inicia el servidor stdio predeterminado con:

cove-book-forge mcp --config /absolute/path/to/config.yaml

El servidor expone operaciones de importación/lectura de la biblioteca, análisis y salidas de capítulos, planificación/trabajos/control/estado de libro completo, descubrimiento de Skills generadas y recursos cove-book-forge:// coincidentes. Todas las herramientas devuelven resultados estructurados definidos por Pydantic. Los errores públicos usan datos seguros de ForgeErrorDetail y no revelan rutas de origen, texto de capítulos, respuestas del Provider ni credenciales.

También está disponible un transporte HTTP local explícito:

cove-book-forge mcp --transport http --host 127.0.0.1 --port 8000 \
  --config /absolute/path/to/config.yaml

El Streamable HTTP no autenticado está restringido a direcciones de bucle local. El servidor no ofrece un modo remoto no autenticado. Las aplicaciones pueden construir un AppContext con un ModelProvider personalizado; la configuración integrada de DeepSeek usa la ruta existente de Provider compatible con OpenAI.

Salida segura de Obsidian

ObsidianOutput publica un capítulo ya analizado de forma síncrona. La bóveda debe existir y estar configurada explícitamente; las raíces de disco, el directorio personal, el directorio de trabajo actual y sus ancestros amplios, las rutas con enlaces simbólicos y las ubicaciones sin permiso de escritura fallan de forma cerrada. La publicación no llama a un Provider ni repara un análisis.

Esta función de capa de aplicación es una composición válida por tipos del límite público de análisis asíncrono y del límite de salida síncrono:

from cove_book_forge.analysis import ChapterAnalyzer
from cove_book_forge.config import AppConfig
from cove_book_forge.contracts import ChapterSnapshot, ObsidianPublishResult
from cove_book_forge.library import BookLibrary
from cove_book_forge.outputs import ObsidianOutput
from cove_book_forge.providers import ModelProvider


async def publish_chapter_to_obsidian(
    provider: ModelProvider,
    library: BookLibrary,
    config: AppConfig,
    snapshot: ChapterSnapshot,
) -> ObsidianPublishResult:
    analyzer = ChapterAnalyzer(provider, library, config.analysis, config.model)
    analyzed = await analyzer.analyze(snapshot)
    return ObsidianOutput(config.outputs.obsidian).publish(snapshot, analyzed)

Una huella de entrada persistente coincidente hace que analyzer.analyze(...) sea un acierto de caché sin llamadas, incluso después de que la aplicación recree sus servicios de biblioteca, analizador y salida. Publicar el resultado sin cambios no reescribe ningún archivo. La identidad de Provider/modelo/base se excluye de la huella por defecto; establece analysis.include_provider_in_fingerprint: true cuando una aplicación requiera que los cambios de proveedor invaliden el análisis almacenado en caché.

El diseño gestionado determinista es:

<Vault>/
├── Books/<safe book title>--<stable book key>/
│   ├── <initial safe book title> MOC.md
│   └── Chapters/<01-based index> <safe chapter title>.md
├── Cards/<safe concept or rule title>--<stable card id>.md
└── .cove-book-forge/obsidian/<stable book key>.json

El manifiesto con suma de verificación preserva la cobertura de capítulos, las entradas de índice, las tarjetas, los marcos y los temas entre publicaciones de capítulos separadas y reinicios del proceso. Los cambios de título visibles para el usuario actualizan los metadatos de visualización gestionados mientras la raíz física del libro y la ruta del MOC permanecen estables. El manifiesto almacena identidades controladas, resúmenes, rutas relativas y hashes, no cuerpos de capítulos fuente, notas privadas, prompts, respuestas del Provider, credenciales ni rutas absolutas.

Cada archivo Markdown gestionado tiene un frontmatter fijo cove_*, incluida su identidad de propiedad y el hash del cuerpo. Cove Book Forge actualiza solo los archivos cuyo marcador gestionado, identidad y hash registrado siguen coincidiendo. Editar una nota gestionada fuera de la aplicación provoca EXTERNAL_MODIFICATION; v0.1 no fusiona Markdown arbitrario y no tiene indicador de sobrescritura. Mantén la prosa personal en notas separadas no gestionadas y enlaza con el material generado.

Las notas de capítulos, las tarjetas de conceptos/reglas relevantes, el MOC agregado y el manifiesto se preparan y confirman como un único paquete recuperable, con el manifiesto al final. Una publicación fallida restaura el último paquete visible correcto cuando puede demostrar la propiedad y nunca adopta ni elimina un archivo en competencia. Una publicación correcta sin cambios es una operación nula byte a byte.

La interfaz privada de lectura Cove puede invocar el límite público de aplicación MCP implementado en este repositorio. El núcleo permanece independiente de la interfaz de usuario: otros sistemas de lectura pueden usar las mismas herramientas y recursos, mientras que los usuarios sin un lector existente pueden construir su propia interfaz alrededor de ellos.

Habilidades de agente generadas

AgentSkillOutput convierte un ChapterSnapshot ya analizado en una Habilidad de agente gestionada de un solo capítulo. Configure un directorio canónico existente y solo las raíces de descubrimiento convencionales que desee usar:

outputs:
  skills:
    enabled: true
    canonical_path: /absolute/path/to/generated-skills
    install_to: [codex, claude, agents]

El límite síncrono público refleja el límite de Obsidian. Acepta un análisis en caché y, por lo tanto, nunca invoca a un Proveedor:

from cove_book_forge.contracts import AnalyzedChapter, ChapterSnapshot
from cove_book_forge.outputs import AgentSkillOutput

result = AgentSkillOutput(config.outputs.skills).publish(snapshot, analyzed)
print(result.skill_slug, result.canonical_path)

Ejecute examples/publish_chapter_skill.py para una demostración local completa. La raíz canónica sigue siendo la fuente de verdad y tiene un diseño gestionado protegido y recuperable. Cada destino seleccionado se instala como un enlace simbólico relativo verificado cuando es compatible; si los enlaces simbólicos no están disponibles, recibe una copia gestionada verificada. Los archivos, directorios y enlaces existentes no gestionados nunca se sobrescriben: una colisión de instalación devuelve INSTALL_CONFLICT mientras deja la Habilidad canónica utilizable. Repetir una publicación sin cambios reutiliza el análisis en caché y realiza una operación no operativa byte por byte.

Después de la instalación, invoque la habilidad generada como $<skill-slug> (por ejemplo, $durable-decisions--0123abcd0123abcd) o haga una solicitud en lenguaje natural que coincida con la descripción de la Habilidad generada. Codex usa ~/.codex/skills, Claude Code usa ~/.claude/skills y los agentes genéricos usan ~/.agents/skills; solo se inspeccionan o modifican las raíces nombradas en install_to.

El mismo límite de salida lo usa la forja de libros completos, que analiza y publica capítulos mediante trabajos persistentes y reanudables. El servidor MCP público expone flujos de trabajo tanto a nivel de capítulo como de libro completo; solo el adaptador de la interfaz privada de Cove permanece fuera de este repositorio de código abierto.

Proveedores de modelos

El límite asíncrono de Proveedor admite openai, openai-compatible, deepseek y anthropic como nombres integrados exactos. Devuelve resultados por llamada tipados y uso acumulativo de tokens de entrada/salida/total. Cada llamada de generación realiza como máximo una solicitud: no hay reintento automático, reparación de JSON ni respaldo a otro proveedor dentro de un adaptador. La capa de análisis de capítulos implementada posee su política separada y acotada de validación/regeneración de esquema descrita anteriormente. El uso de proveedores de confianza se cuenta incluso cuando una respuesta facturada falla posteriormente en la terminación, el contenido o la validación de objetos JSON.

Los valores de clave de API se leen solo de la variable de entorno del proceso nombrada. Ponga el nombre de la variable —no la clave— en YAML, y proporcione el valor a través de su shell, administrador de servicios o administrador de secretos. Las claves, indicaciones, URL y cuerpos de respuesta sin procesar se excluyen de los errores públicos y no se registran en la capa de Proveedor. openai, deepseek y anthropic requieren una credencial configurada y no vacía; los openai-compatible genéricos y los Proveedores personalizados registrados explícitamente pueden omitirla.

DeepSeek

DeepSeek usa el protocolo de finalización de chat compatible con OpenAI y la base de API integrada de DeepSeek:

model:
  provider: deepseek
  model: deepseek-chat
  api_key_env: DEEPSEEK_API_KEY

Puerta de enlace compatible con OpenAI o autoalojada

Se requiere una base_url explícita. api_key_env es opcional para una puerta de enlace local; cuando se configura, su valor de entorno debe ser no vacío.

model:
  provider: openai-compatible
  model: local-reader-model
  base_url: http://127.0.0.1:11434/v1
  # json_mode: true  # opt in only when this gateway supports native JSON Mode
  # api_key_env: LOCAL_MODEL_API_KEY

Anthropic Claude

Claude usa la API de Mensajes de Anthropic:

model:
  provider: anthropic
  model: claude-sonnet-4-5
  api_key_env: ANTHROPIC_API_KEY

OpenAI y DeepSeek usan por defecto el modo nativo de objetos JSON. El openai-compatible genérico usa por defecto JSON solo con indicación; establezca el json_mode: true opcional solo para una puerta de enlace que admita response_format, o establezca false para deshabilitar el modo nativo para OpenAI o DeepSeek. Cada ruta añade la instrucción controlada de objeto directo y acepta estrictamente un objeto JSON. Anthropic siempre anuncia el modo nativo de JSON y JSON Schema como no disponibles e ignora una anulación de estilo OpenAI. Los máximos de capacidad de salida permanecen desconocidos; default_max_output_tokens es un valor predeterminado del llamador, no un límite estricto del proveedor. La validación de esquema de dominio y una regeneración acotada de salida no válida las proporciona ChapterAnalyzer, no el adaptador de Proveedor.

Los Proveedores integrados creados por un ProviderRegistry propiedad de la aplicación comparten la concurrencia configurada y los límites de solicitud de 60 segundos entre modelos en la misma ruta e identidad de credencial. Cada instancia mantiene su propio uso acumulativo. Los registros separados están aislados, por lo que una aplicación de incrustación debe reutilizar su registro para un límite de aplicación.

Registro explícito de Proveedor personalizado

Las aplicaciones pueden registrar un Proveedor local o propietario tipado explícitamente, sin descubrimiento de complementos ni rutas de importación dinámicas:

from your_application.providers import custom_provider_factory

from cove_book_forge.config import ModelConfig
from cove_book_forge.providers import ProviderRegistry

registry = ProviderRegistry({"deterministic-local": custom_provider_factory})
provider = registry.create(ModelConfig(provider="deterministic-local", model="reader-model"))

Consulte el ejemplo de código fuente del repositorio/sdist examples/custom_provider.py para una implementación tipada completa. Es material fuente, no un espacio de nombres de paquete wheel; cópielo o adáptelo bajo su propio paquete de aplicación antes de usar la importación anterior. El comando independiente doctor reconoce solo los integrados exactos; una aplicación de incrustación es propietaria de las comprobaciones de preparación para sus Proveedores personalizados registrados explícitamente.

Valores predeterminados de privacidad y diagnósticos

• Los datos de la biblioteca y las instantáneas normalizadas permanecen locales.

• La telemetría, la sincronización en la nube, el registro remoto y los respaldos de red ocultos están deshabilitados.

• Los valores de clave de API provienen de variables de entorno y nunca se almacenan en YAML.

• Las raíces de salida configuradas requieren autorización explícita. La publicación en Obsidian permanece local y escribe solo su paquete gestionado validado dentro de esa bóveda.

El comando doctor es de solo lectura y sin red. Comprueba la configuración, la preparación del Proveedor/base integrado, la presencia de variables de entorno requeridas, las dependencias del analizador EPUB/PDF, la preparación del directorio de biblioteca configurado, cualquier library.sqlite3 existente mediante una comprobación de integridad SQLite de solo lectura, y la bóveda de Obsidian habilitada mediante el mismo límite de preparación estrecho sin seguimiento que usa la publicación. Nunca renderiza ni publica salida, llama a las API de generación o comprobación de estado del Proveedor, ni crea directorios, bases de datos, diarios, archivos WAL, archivos temporales, manifiestos o migraciones. La salida de Obsidian deshabilitada es una advertencia sin fallo; una bóveda configurada faltante, amplia, enlazada o no escribible es un fallo seguro sin rutas.

uv sync --group dev
uv run cove-book-forge doctor --config /absolute/path/config.yaml

Si la importación gestionada está deshabilitada y la caché externa opcional aún no existe, doctor informa una advertencia sin fallo cuando su padre existente está listo. Las bases de datos existentes inseguras, ilegibles o no válidas siguen siendo fallos.

Verificación del colaborador

Ejecute la secuencia completa de verificación local antes de enviar un cambio:

uv lock --check
uv run --no-sync pytest --cov=cove_book_forge --cov-report=term-missing
uv run --no-sync ruff check .
uv run --no-sync ruff format --check .
uv run --no-sync mypy src/cove_book_forge
uv run --no-sync mypy examples/custom_provider.py
uv build --clear
uv run --no-sync python scripts/verify_distribution.py dist

Las pruebas de Proveedor usan solo transportes simulados locales y Proveedores falsos deterministas; el conjunto de pruebas no realiza ninguna solicitud de modelo en vivo y no requiere una cuenta o clave real.

Agradecimientos

cove-book-forge-mcp está inspirado en y se basa en ideas y herramientas de book-to-skill, creado por Virgilio Jr. Agradecemos su trabajo de extracción de documentos, la estructura de Habilidades de agente y su contribución de código abierto. El aviso de saneador adaptado concreto se conserva en THIRD_PARTY_NOTICES.md.

Licencia

MIT. Consulte LICENSE y los términos de terceros incluidos en THIRD_PARTY_NOTICES.md.