# Input, Network, and LLM Capabilities for Each Capture Adapter in Claude Obsidian

> Explore Claude Obsidian's capture adapters discover input types network access and LLM capabilities for each ingestion method. Optimize your data workflow now.

- Repository: [Agrici.Daniel/claude-obsidian](https://github.com/AgriciDaniel/claude-obsidian)
- Tags: deep-dive
- Published: 2026-08-29

---

**Claude Obsidian defines seven distinct capture adapters in [`config/adapters.json`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/config/adapters.json) that declare specific input types alongside Boolean flags indicating whether network access and LLM processing are required for each ingestion method.**

The `claude-obsidian` repository implements a modular capture system where every adapter is annotated with capability metadata. These flags—`network` and `llm`—determine whether an adapter can operate offline and whether it invokes language-model-driven pipelines for content extraction or summarization.

## Capture Adapter Capability Overview

In [`config/adapters.json`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/config/adapters.json), each adapter entry specifies three core properties: the **input type** it handles, its **network** requirement, and its **LLM** dependency. The manifest serves as the declarative registry that [`claude_obsidian/capture.py`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/claude_obsidian/capture.py) consults before dispatching operations. According to the source code, adapters with `"network": true` require external connectivity to retrieve resources, while those with `"llm": true` pass content to AI services for OCR, summarization, or analysis.

## Adapter-by-Adapter Capability Breakdown

### Filesystem Adapter (Local File Paths)

The `filesystem` adapter processes documents from the visible inbox using purely local operations. As recorded at line 15 of [`config/adapters.json`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/config/adapters.json), this adapter sets both `"network": false` and `"llm": false`. It handles standard file ingestion without external API calls or AI processing.

### URL Adapter (Remote HTTPS Resources)

The `url` adapter ingests content from remote hosts via HTTPS. The manifest at line 47 declares `"network": true` because the adapter must contact external servers to retrieve resources, but `"llm": false` since it only fetches raw data without AI transformation.

### Image Adapter (Visual Content with LLM OCR)

Unlike the filesystem adapter, the `image` adapter (line 57) operates on local image files but requires LLM capabilities. With `"network": false` and `"llm": true`, this adapter passes PNG and JPEG files to an LLM-based OCR pipeline for text extraction while remaining fully offline for the initial file read.

### PDF Adapter (Document Analysis)

The `pdf` adapter handles local PDF files with AI-driven processing. According to line 68 of the configuration, it sets `"network": false` and `"llm": true`. The adapter extracts text from PDFs and feeds the content to Claude for summarization and analysis without requiring internet access.

### YouTube Adapter (Media Retrieval)

For video ingestion, the `youtube` adapter (line 79) requires network access to download audio and video streams, declaring `"network": true`. However, it sets `"llm": false` because the adapter's responsibility ends at media retrieval; any downstream transcription or analysis is handled by separate skills.

### EPUB Adapter (Ebook Processing)

The `epub` adapter processes local ebook files with language model assistance. At line 90, the manifest shows `"network": false` and `"llm": true`, indicating that while the file is read locally, the parsed contents are handed to an LLM for structured processing and summarization.

### OCR Adapter (Dedicated Text Extraction)

Specifically designed for optical character recognition, the `ocr` adapter (line 101) processes image files locally (`"network": false`) but relies entirely on LLM-backed OCR services (`"llm": true`) to extract text from visual data.

## Implementation in the Capture Module

The [`claude_obsidian/capture.py`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/claude_obsidian/capture.py) file implements the capability validation logic. Before executing any capture operation, the dispatcher reads the adapter manifest and verifies that the requested operation meets the declared constraints. For example, attempting to use the `url` adapter without network permissions raises a validation error based on the `"network": true` flag defined in the JSON registry.

The module exposes `capture_filesystem` and `capture_filesystem_batch` functions that route inputs according to their detected type. While the function names suggest filesystem operations, the underlying dispatcher uses the manifest's input type definitions to select the appropriate adapter—whether that involves local file handling, remote HTTP requests, or LLM-powered document analysis.

## Practical Usage Examples

The following patterns demonstrate how different capabilities affect capture operations:

```python
from claude_obsidian.capture import capture_filesystem
from pathlib import Path

vault = Path("/path/to/vault")

# Local file: network=false, llm=false (filesystem adapter)

local_file = Path("/path/to/vault/inbox/example.txt")
result = capture_filesystem(vault, local_file)
print(result["stored_path"])   # → .raw/captured/example.txt

```

```python

# Remote URL: network=true, llm=false (url adapter)

# Requires network capability enabled

result = capture_filesystem(vault, "https://example.com/data.json")

```

```python

# PDF with AI analysis: network=false, llm=true (pdf adapter)

# Processes locally but sends text to LLM

pdf_path = Path("/path/to/vault/inbox/report.pdf")
result = capture_filesystem(vault, pdf_path)

# Internally extracts text and requests Claude summarization

```

Unit tests in [`tests/test_capture.py`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/tests/test_capture.py) verify that each adapter respects its declared capabilities, ensuring that LLM-dependent adapters like `image`, `pdf`, `epub`, and `ocr` properly initialize AI pipelines, while network-dependent adapters like `url` and `youtube` validate connectivity before execution.

## Summary

- **Seven adapters** are defined in [`config/adapters.json`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/config/adapters.json) with explicit capability flags.
- **Network capabilities** are required only by the `url` (line 47) and `youtube` (line 79) adapters for remote resource retrieval.
- **LLM capabilities** are enabled for `image` (line 57), `pdf` (line 68), `epub` (line 90), and `ocr` (line 101) adapters to support AI-driven text extraction and analysis.
- **Offline operation** is possible with `filesystem`, `image`, `pdf`, `epub`, and `ocr` adapters since they declare `"network": false`.
- The [`capture.py`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/capture.py) module validates these flags before dispatching operations to ensure secure, capability-appropriate content ingestion.

## Frequently Asked Questions

### Which capture adapters require an internet connection to function?

Only the `url` and `youtube` adapters require network access according to the manifest at [`config/adapters.json`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/config/adapters.json). The `url` adapter needs connectivity to fetch remote HTTPS resources (line 47), while the `youtube` adapter downloads video and audio streams from external servers (line 79). All other adapters—including `filesystem`, `image`, `pdf`, `epub`, and `ocr`—operate entirely on local files with `"network": false`.

### Do any adapters process content without using an LLM?

Yes, three adapters function without LLM processing. The `filesystem` adapter handles raw file moves and copies locally (line 15), the `url` adapter fetches remote data as-is (line 47), and the `youtube` adapter retrieves media streams without AI intervention (line 79). These adapters set `"llm": false` in the configuration registry.

### How does the capture module determine which adapter to use?

The [`claude_obsidian/capture.py`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/claude_obsidian/capture.py) dispatcher inspects the input type and consults [`config/adapters.json`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/config/adapters.json) to match the resource against adapter capabilities. For example, when receiving a local PDF path, it selects the `pdf` adapter (line 68), verifies that `"llm": true` is available, and then invokes the LLM pipeline for text extraction. The module validates both network and LLM permissions against the manifest flags before execution.

### Can the OCR adapter work offline?

While the `ocr` adapter reads image files locally and declares `"network": false` (line 101), it requires `"llm": true`. This means it depends on a local or externally configured LLM service for text recognition. If the LLM service runs locally, the adapter operates offline; if it relies on cloud-based models, network access is effectively required despite the adapter's network flag being false.