cocoindex 0.1.54__tar.gz → 0.1.55__tar.gz

{cocoindex-0.1.54 → cocoindex-0.1.55}/.github/workflows/CI.yml

@@ -26,7 +26,19 @@ permissions:
   contents: read
 
 jobs:
-  format-check:
+  rust-format-check:
+    name: Check Rust formatting
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt
+      - name: Check Rust formatting
+        run: |
+          cargo fmt --check
+
+  python-format-check:
     name: Check Python formatting
     runs-on: ubuntu-latest
     steps:

{cocoindex-0.1.54 → cocoindex-0.1.55}/Cargo.lock

@@ -1040,7 +1040,7 @@ dependencies = [
 
 [[package]]
 name = "cocoindex"
-version = "0.1.54"
+version = "0.1.55"
 dependencies = [
  "anyhow",
  "async-openai",
@@ -3293,6 +3293,7 @@ dependencies = [
  "pyo3-ffi",
  "pyo3-macros",
  "unindent",
+ "uuid",
 ]
 
 [[package]]

{cocoindex-0.1.54 → cocoindex-0.1.55}/Cargo.toml

@@ -2,7 +2,7 @@
 name = "cocoindex"
 # Version used for local development is always higher than others to take precedence.
 # Will be overridden for specific release versions.
-version = "0.1.54"
+version = "0.1.55"
 edition = "2024"
 rust-version = "1.86"
 
@@ -15,7 +15,7 @@ name = "cocoindex_engine"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = { version = "0.25.0", features = ["chrono", "auto-initialize"] }
+pyo3 = { version = "0.25.0", features = ["chrono", "auto-initialize", "uuid"] }
 pythonize = "0.25.0"
 pyo3-async-runtimes = { version = "0.25.0", features = ["tokio-runtime"] }
 

{cocoindex-0.1.54 → cocoindex-0.1.55}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: cocoindex
-Version: 0.1.54
+Version: 0.1.55
 Requires-Dist: sentence-transformers>=3.3.1
 Requires-Dist: click>=8.1.8
 Requires-Dist: rich>=14.0.0
 Requires-Dist: python-dotenv>=1.1.0
+Requires-Dist: watchfiles>=1.1.0
 Requires-Dist: pytest ; extra == 'test'
 Requires-Dist: ruff ; extra == 'dev'
 Requires-Dist: pre-commit ; extra == 'dev'

cocoindex-0.1.55/docs/docs/ai/llm.mdx

@@ -0,0 +1,309 @@
+---
+title: LLM Support
+description: LLMs integrated with CocoIndex for various built-in functions
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+CocoIndex provides builtin functions integrating with various LLM APIs, for various inference tasks:
+*   [Text Generation](#text-generation): use LLM to generate text.
+*   [Text Embedding](#text-embedding): embed text into a vector space.
+
+## LLM API Types
+
+We support integrating with LLM with different types of APIs.
+Each LLM API type is specified by a `cocoindex.LlmApiType` enum.
+
+We support the following types of LLM APIs:
+
+| API Name | `LlmApiType` enum | Text Generation | Text Embedding |
+|----------|---------------------|--------------------|--------------------|
+| [OpenAI](#openai) | `LlmApiType.OPENAI` | ✅ | ✅ |
+| [Ollama](#ollama) | `LlmApiType.OLLAMA` | ✅ | ❌ |
+| [Google Gemini](#google-gemini) | `LlmApiType.GEMINI` | ✅ | ✅ |
+| [Anthropic](#anthropic) | `LlmApiType.ANTHROPIC` | ✅ | ❌ |
+| [Voyage](#voyage) | `LlmApiType.VOYAGE` | ❌ | ✅ |
+| [LiteLLM](#litellm) | `LlmApiType.LITE_LLM` | ✅ | ❌ |
+| [OpenRouter](#openrouter) | `LlmApiType.OPEN_ROUTER` | ✅ | ❌ |
+
+## LLM Tasks
+
+### Text Generation
+
+Generation is used as a building block for certain CocoIndex functions that process data using LLM generation.
+
+We have one builtin functions using LLM generation for now:
+
+*  [`ExtractByLlm`](/docs/ops/functions#extractbyllm): it extracts information from input text.
+
+#### LLM Spec
+
+When calling a CocoIndex function that uses LLM generation, you need to provide a `cocoindex.LlmSpec` dataclass, to configure the LLM you want to use in these functions.
+It has the following fields:
+
+*   `api_type` (type: [`cocoindex.LlmApiType`](/docs/ai/llm#llm-api-types), required): The type of integrated LLM API to use, e.g. `cocoindex.LlmApiType.OPENAI` or `cocoindex.LlmApiType.OLLAMA`.
+    See supported LLM APIs in the [LLM API integrations](#llm-api-integrations) section below.
+*   `model` (type: `str`, required): The name of the LLM model to use.
+*   `address` (type: `str`, optional): The address of the LLM API.
+
+
+### Text Embedding
+
+Embedding means converting text into a vector space, usually for similarity matching.
+
+We provide a builtin function [`EmbedText`](/docs/ops/functions#embedtext) that converts a given text into a vector space.
+The spec takes the following fields:
+
+*   `api_type` (type: `cocoindex.LlmApiType`, required)
+*   `model` (type: `str`, required)
+*   `address` (type: `str`, optional)
+*   `output_dimension` (type: `int`, optional)
+*   `task_type` (type: `str`, optional)
+
+See documentation for [`EmbedText`](/docs/ops/functions#embedtext) for more details about these fields.
+
+## LLM API Integrations
+
+CocoIndex integrates with various LLM APIs for these functions.
+
+### OpenAI
+
+To use the OpenAI LLM API, you need to set the environment variable `OPENAI_API_KEY`.
+You can generate the API key from [OpenAI Dashboard](https://platform.openai.com/api-keys).
+
+Currently we don't support custom address for OpenAI API.
+
+You can find the full list of models supported by OpenAI [here](https://platform.openai.com/docs/models).
+
+For text generation, a spec for OpenAI looks like this:
+
+<Tabs>
+<TabItem value="python" label="Python" default>
+
+```python
+cocoindex.LlmSpec(
+    api_type=cocoindex.LlmApiType.OPENAI,
+    model="gpt-4o",
+)
+```
+
+</TabItem>
+</Tabs>
+
+For text embedding, a spec for OpenAI looks like this:
+
+<Tabs>
+<TabItem value="python" label="Python" default>
+
+```python
+cocoindex.functions.EmbedText(
+    api_type=cocoindex.LlmApiType.OPENAI,
+    model="text-embedding-3-small",
+)
+```
+
+</TabItem>
+</Tabs>
+
+### Ollama
+
+[Ollama](https://ollama.com/) allows you to run LLM models on your local machine easily. To get started:
+
+*   [Download](https://ollama.com/download) and install Ollama.
+*   Pull your favorite LLM models by the `ollama pull` command, e.g.
+    ```bash
+    ollama pull llama3.2
+    ```
+You can find the [list of models](https://ollama.com/library) supported by Ollama.
+
+A spec for Ollama looks like this:
+
+<Tabs>
+<TabItem value="python" label="Python" default>
+
+```python
+cocoindex.LlmSpec(
+    api_type=cocoindex.LlmApiType.OLLAMA,
+    model="llama3.2:latest",
+    # Optional, use Ollama's default port (11434) on localhost if not specified
+    address="http://localhost:11434",
+)
+```
+
+</TabItem>
+</Tabs>
+
+### Google Gemini
+
+To use the Gemini LLM API, you need to set the environment variable `GEMINI_API_KEY`.
+You can generate the API key from [Google AI Studio](https://aistudio.google.com/apikey).
+
+You can find the full list of models supported by Gemini [here](https://ai.google.dev/gemini-api/docs/models).
+
+For text generation, a spec looks like this:
+
+<Tabs>
+<TabItem value="python" label="Python" default>
+
+```python
+cocoindex.LlmSpec(
+    api_type=cocoindex.LlmApiType.GEMINI,
+    model="gemini-2.0-flash",
+)
+```
+
+</TabItem>
+</Tabs>
+
+For text embedding, a spec looks like this:
+
+<Tabs>
+<TabItem value="python" label="Python" default>
+
+```python
+cocoindex.functions.EmbedText(
+    api_type=cocoindex.LlmApiType.GEMINI,
+    model="text-embedding-004",
+    task_type="SEMANTICS_SIMILARITY",
+)
+```
+
+All supported embedding models can be found [here](https://ai.google.dev/gemini-api/docs/embeddings#embeddings-models).
+Gemini supports task type (optional), which can be found [here](https://ai.google.dev/gemini-api/docs/embeddings#supported-task-types).
+
+
+</TabItem>
+</Tabs>
+
+### Anthropic
+
+To use the Anthropic LLM API, you need to set the environment variable `ANTHROPIC_API_KEY`.
+You can generate the API key from [Anthropic API](https://console.anthropic.com/settings/keys).
+
+A text generation spec for Anthropic looks like this:
+
+<Tabs>
+<TabItem value="python" label="Python" default>
+
+```python
+cocoindex.LlmSpec(
+    api_type=cocoindex.LlmApiType.ANTHROPIC,
+    model="claude-3-5-sonnet-latest",
+)
+```
+
+</TabItem>
+</Tabs>
+
+You can find the full list of models supported by Anthropic [here](https://docs.anthropic.com/en/docs/about-claude/models/all-models).
+
+### Voyage
+
+To use the Voyage LLM API, you need to set the environment variable `VOYAGE_API_KEY`.
+You can generate the API key from [Voyage dashboard](https://dashboard.voyageai.com/organization/api-keys).
+
+A text embedding spec for Voyage looks like this:
+
+<Tabs>
+<TabItem value="python" label="Python" default>
+
+```python
+cocoindex.functions.EmbedText(
+    api_type=cocoindex.LlmApiType.VOYAGE,
+    model="voyage-code-3",
+    task_type="document",
+)
+```
+
+</TabItem>
+</Tabs>
+
+Voyage API supports `document` and `query` as task types (optional, a.k.a. `input_type` in Voyage API, see [Voyage API documentation](https://docs.voyageai.com/reference/embeddings-api) for details).
+
+### LiteLLM
+
+To use the LiteLLM API, you need to set the environment variable `LITELLM_API_KEY`.
+
+#### 1. Install LiteLLM Proxy
+
+```bash
+pip install 'litellm[proxy]'
+```
+
+#### 2. Create a `config.yml` for LiteLLM
+
+**Example for DeepSeek:**
+
+Use this in your `config.yml`:
+
+```yaml
+model_list:
+  - model_name: deepseek-chat
+    litellm_params:
+        model: deepseek/deepseek-chat
+        api_key: os.environ/DEEPSEEK_API_KEY
+```
+
+You need to set the environment variable `DEEPSEEK_API_KEY` to your DeepSeek API key.
+
+**Example for Groq:**
+
+Use this in your `config.yml`:
+
+```yaml
+model_list:
+  - model_name: groq-llama-3.3-70b-versatile
+    litellm_params:
+      model: groq/llama-3.3-70b-versatile
+      api_key: "os.environ/GROQ_API_KEY"
+```
+
+You need to set the environment variable `GROQ_API_KEY` to your Groq API key.
+
+
+#### 3. Run LiteLLM Proxy
+
+```bash
+litellm --config config.yml
+```
+
+#### 4. A Spec for LiteLLM will look like this:
+
+<Tabs>
+<TabItem value="python" label="Python" default>
+
+```python
+cocoindex.LlmSpec(
+    api_type=cocoindex.LlmApiType.LITE_LLM,
+    model="deepseek-chat",
+    address="http://127.0.0.1:4000", # default url of LiteLLM
+)
+```
+
+</TabItem>
+</Tabs>
+
+You can find the full list of models supported by LiteLLM [here](https://docs.litellm.ai/docs/providers).
+
+### OpenRouter
+
+To use the OpenRouter API, you need to set the environment variable `OPENROUTER_API_KEY`.
+You can generate the API key from [here](https://openrouter.ai/settings/keys).
+
+A spec for OpenRouter looks like this:
+
+<Tabs>
+<TabItem value="python" label="Python" default>
+
+```python
+cocoindex.LlmSpec(
+    api_type=cocoindex.LlmApiType.OPEN_ROUTER,
+    model="deepseek/deepseek-r1:free",
+)
+```
+
+</TabItem>
+</Tabs>
+
+You can find the full list of models supported by OpenRouter [here](https://openrouter.ai/models).

cocoindex-0.1.55/docs/docs/ops/functions.md

@@ -0,0 +1,142 @@
+---
+title: Functions
+description: CocoIndex Built-in Functions
+---
+
+# CocoIndex Built-in Functions
+
+## ParseJson
+
+`ParseJson` parses a given text to JSON.
+
+The spec takes the following fields:
+
+*   `text` (`str`): The source text to parse.
+*   `language` (`str`, optional): The language of the source text.  Only `json` is supported now.  Default to `json`.
+
+Return: *Json*
+
+## SplitRecursively
+
+`SplitRecursively` splits a document into chunks of a given size.
+It tries to split at higher-level boundaries. If each chunk is still too large, it tries at the next level of boundaries.
+For example, for a Markdown file, it identifies boundaries in this order: level-1 sections, level-2 sections, level-3 sections, paragraphs, sentences, etc.
+
+The spec takes the following fields:
+
+*   `custom_languages` (`list[CustomLanguageSpec]`, optional): This allows you to customize the way to chunking specific languages using regular expressions. Each `CustomLanguageSpec` is a dict with the following fields:
+    *   `language_name` (`str`): Name of the language.
+    *   `aliases` (`list[str]`, optional): A list of aliases for the language.
+        It's an error if any language name or alias is duplicated.
+
+    *   `separators_regex` (`list[str]`): A list of regex patterns to split the text.
+        Higher-level boundaries should come first, and lower-level should be listed later. e.g. `[r"\n# ", r"\n## ", r"\n\n", r"\. "]`.
+        See [regex Syntax](https://docs.rs/regex/latest/regex/#syntax) for supported regular expression syntax.
+
+Input data:
+
+*   `text` (*Str*): The text to split.
+*   `chunk_size` (*Int64*): The maximum size of each chunk, in bytes.
+*   `min_chunk_size` (*Int64*, optional): The minimum size of each chunk, in bytes. If not provided, default to `chunk_size / 2`.
+
+    :::note
+
+    `SplitRecursively` will do its best to make the output chunks sized between `min_chunk_size` and `chunk_size`.
+    However, it's possible that some chunks are smaller than `min_chunk_size` or larger than `chunk_size` in rare cases, e.g. too short input text, or non-splittable large text.
+
+    Please avoid setting `min_chunk_size` to a value too close to `chunk_size`, to leave more rooms for the function to plan the optimal chunking.
+
+    :::
+
+*   `chunk_overlap` (*Int64*, optional): The maximum overlap size between adjacent chunks, in bytes.
+*   `language` (*Str*, optional): The language of the document.
+    Can be a language name (e.g. `Python`, `Javascript`, `Markdown`) or a file extension (e.g. `.py`, `.js`, `.md`).
+
+
+    :::note
+
+    We use the `language` field to determine how to split the input text, following these rules:
+
+    *   We'll match the input `language` field against the `language_name` or `aliases` of each element of `custom_languages`, and use the matched one. If value of `language` is null, it'll be treated as empty string when matching `language_name` or `aliases`.
+    *   If no match is found, we'll match the `language` field against the builtin language configurations.
+        For all supported builtin language names and aliases (extensions), see [the code](https://github.com/search?q=org%3Acocoindex-io+lang%3Arust++%22static+TREE_SITTER_LANGUAGE_BY_LANG%22&type=code).
+    *   If no match is found, the input will be treated as plain text.
+
+    :::
+
+Return: [*KTable*](/docs/core/data_types#ktable), each row represents a chunk, with the following sub fields:
+
+*   `location` (*Range*): The location of the chunk.
+*   `text` (*Str*): The text of the chunk.
+*   `start` / `end` (*Struct*): Details about the start position (inclusive) and end position (exclusive) of the chunk. They have the following sub fields:
+    *   `offset` (*Int64*): The byte offset of the position.
+    *   `line` (*Int64*): The line number of the position. Starting from 1.
+    *   `column` (*Int64*): The column number of the position. Starting from 1.
+
+## SentenceTransformerEmbed
+
+`SentenceTransformerEmbed` embeds a text into a vector space using the [SentenceTransformer](https://huggingface.co/sentence-transformers) library.
+
+The spec takes the following fields:
+
+*   `model` (`str`): The name of the SentenceTransformer model to use.
+*   `args` (`dict[str, Any]`, optional): Additional arguments to pass to the SentenceTransformer constructor. e.g. `{"trust_remote_code": True}`
+
+Input data:
+
+*   `text` (*Str*): The text to embed.
+
+Return: *Vector[Float32, N]*, where *N* is determined by the model
+
+## ExtractByLlm
+
+`ExtractByLlm` extracts structured information from a text using specified LLM. The spec takes the following fields:
+
+*   `llm_spec` (`cocoindex.LlmSpec`): The specification of the LLM to use. See [LLM Spec](/docs/ai/llm#llm-spec) for more details.
+*   `output_type` (`type`): The type of the output. e.g. a dataclass type name. See [Data Types](/docs/core/data_types) for all supported data types. The LLM will output values that match the schema of the type.
+*   `instruction` (`str`, optional): Additional instruction for the LLM.
+
+:::tip Clear type definitions
+
+Definitions of the `output_type` is fed into LLM as guidance to generate the output.
+To improve the quality of the extracted information, giving clear definitions for your dataclasses is especially important, e.g.
+
+*   Provide readable field names for your dataclasses.
+*   Provide reasonable docstrings for your dataclasses.
+*   For any optional fields, clearly annotate that they are optional, by `SomeType | None` or `typing.Optional[SomeType]`.
+
+:::
+
+Input data:
+
+*   `text` (*Str*): The text to extract information from.
+
+Return: As specified by the `output_type` field in the spec. The extracted information from the input text.
+
+## EmbedText
+
+`EmbedText` embeds a text into a vector space using various LLM APIs that support text embedding.
+
+The spec takes the following fields:
+
+*   `api_type` ([`cocoindex.LlmApiType`](/docs/ai/llm#llm-api-types)): The type of LLM API to use for embedding.
+*   `model` (`str`): The name of the embedding model to use.
+*   `address` (`str`, optional): The address of the LLM API. If not specified, uses the default address for the API type.
+*   `output_dimension` (`int`, optional): The expected dimension of the output embedding vector. If not specified, use the default dimension of the model.
+
+    For most API types, the function internally keeps a registry for the default output dimension of known model.
+    You need to explicitly specify the `output_dimension` if you want to use a new model that is not in the registry yet.
+
+*   `task_type` (`str`, optional): The task type for embedding, used by some embedding models to optimize the embedding for specific use cases.
+
+:::note Supported APIs for Text Embedding
+
+Not all LLM APIs support text embedding. See the [LLM API Types table](/docs/ai/llm#llm-api-types) for which APIs support text embedding functionality.
+
+:::
+
+Input data:
+
+*   `text` (*Str*, required): The text to embed.
+
+Return: *Vector[Float32, N]*, where *N* is the dimension of the embedding vector determined by the model.

{cocoindex-0.1.54 → cocoindex-0.1.55}/docs/docs/ops/sources.md

@@ -13,11 +13,11 @@ The `LocalFile` source imports files from a local file system.
 ### Spec
 
 The spec takes the following fields:
-*   `path` (type: `str`, required): full path of the root directory to import files from
-*   `binary` (type: `bool`, optional): whether reading files as binary (instead of text)
-*   `included_patterns` (type: `list[str]`, optional): a list of glob patterns to include files, e.g. `["*.txt", "docs/**/*.md"]`.
+*   `path` (`str`): full path of the root directory to import files from
+*   `binary` (`bool`, optional): whether reading files as binary (instead of text)
+*   `included_patterns` (`list[str]`, optional): a list of glob patterns to include files, e.g. `["*.txt", "docs/**/*.md"]`.
     If not specified, all files will be included.
-*   `excluded_patterns` (type: `list[str]`, optional): a list of glob patterns to exclude files, e.g. `["tmp", "**/node_modules"]`.
+*   `excluded_patterns` (`list[str]`, optional): a list of glob patterns to exclude files, e.g. `["tmp", "**/node_modules"]`.
     Any file or directory matching these patterns will be excluded even if they match `included_patterns`.
     If not specified, no files will be excluded.
 
@@ -29,9 +29,9 @@ The spec takes the following fields:
 
 ### Schema
 
-The output is a [KTable](/docs/core/data_types#ktable) with the following sub fields:
-*   `filename` (key, type: `str`): the filename of the file, including the path, relative to the root directory, e.g. `"dir1/file1.md"`
-*   `content` (type: `str` if `binary` is `False`, otherwise `bytes`): the content of the file
+The output is a [*KTable*](/docs/core/data_types#ktable) with the following sub fields:
+*   `filename` (*Str*, key): the filename of the file, including the path, relative to the root directory, e.g. `"dir1/file1.md"`
+*   `content` (*Str* if `binary` is `False`, *Bytes* otherwise): the content of the file
 
 ## AmazonS3
 
@@ -121,12 +121,12 @@ AWS's [Guide of Configuring a Bucket for Notifications](https://docs.aws.amazon.
 ### Spec
 
 The spec takes the following fields:
-*   `bucket_name` (type: `str`, required): Amazon S3 bucket name.
-*   `prefix` (type: `str`, optional): if provided, only files with path starting with this prefix will be imported.
-*   `binary` (type: `bool`, optional): whether reading files as binary (instead of text).
-*   `included_patterns` (type: `list[str]`, optional): a list of glob patterns to include files, e.g. `["*.txt", "docs/**/*.md"]`.
+*   `bucket_name` (`str`): Amazon S3 bucket name.
+*   `prefix` (`str`, optional): if provided, only files with path starting with this prefix will be imported.
+*   `binary` (`bool`, optional): whether reading files as binary (instead of text).
+*   `included_patterns` (`list[str]`, optional): a list of glob patterns to include files, e.g. `["*.txt", "docs/**/*.md"]`.
     If not specified, all files will be included.
-*   `excluded_patterns` (type: `list[str]`, optional): a list of glob patterns to exclude files, e.g. `["*.tmp", "**/*.log"]`.
+*   `excluded_patterns` (`list[str]`, optional): a list of glob patterns to exclude files, e.g. `["*.tmp", "**/*.log"]`.
     Any file or directory matching these patterns will be excluded even if they match `included_patterns`.
     If not specified, no files will be excluded.
 
@@ -136,7 +136,7 @@ The spec takes the following fields:
 
     :::
 
-*   `sqs_queue_url` (type: `str`, optional): if provided, the source will receive change event notifications from Amazon S3 via this SQS queue.
+*   `sqs_queue_url` (`str`, optional): if provided, the source will receive change event notifications from Amazon S3 via this SQS queue.
 
     :::info
 
@@ -147,9 +147,9 @@ The spec takes the following fields:
 
 ### Schema
 
-The output is a [KTable](/docs/core/data_types#ktable) with the following sub fields:
-*   `filename` (key, type: `str`): the filename of the file, including the path, relative to the root directory, e.g. `"dir1/file1.md"`.
-*   `content` (type: `str` if `binary` is `False`, otherwise `bytes`): the content of the file.
+The output is a [*KTable*](/docs/core/data_types#ktable) with the following sub fields:
+*   `filename` (*Str*, key): the filename of the file, including the path, relative to the root directory, e.g. `"dir1/file1.md"`.
+*   `content` (*Str* if `binary` is `False`, otherwise *Bytes*): the content of the file.
 
 
 ## GoogleDrive
@@ -176,10 +176,10 @@ To access files in Google Drive, the `GoogleDrive` source will need to authentic
 
 The spec takes the following fields:
 
-*   `service_account_credential_path` (type: `str`, required): full path to the service account credential file in JSON format.
-*   `root_folder_ids` (type: `list[str]`, required): a list of Google Drive folder IDs to import files from.
-*   `binary` (type: `bool`, optional): whether reading files as binary (instead of text).
-*   `recent_changes_poll_interval` (type: `datetime.timedelta`, optional): when set, this source provides a change capture mechanism by polling Google Drive for recent modified files periodically.
+*   `service_account_credential_path` (`str`): full path to the service account credential file in JSON format.
+*   `root_folder_ids` (`list[str]`): a list of Google Drive folder IDs to import files from.
+*   `binary` (`bool`, optional): whether reading files as binary (instead of text).
+*   `recent_changes_poll_interval` (`datetime.timedelta`, optional): when set, this source provides a change capture mechanism by polling Google Drive for recent modified files periodically.
 
     :::info
 
@@ -198,9 +198,9 @@ The spec takes the following fields:
 
 ### Schema
 
-The output is a [KTable](/docs/core/data_types#ktable) with the following sub fields:
+The output is a [*KTable*](/docs/core/data_types#ktable) with the following sub fields:
 
-*   `file_id` (key, type: `str`): the ID of the file in Google Drive.
-*   `filename` (type: `str`): the filename of the file, without the path, e.g. `"file1.md"`
-*   `mime_type` (type: `str`): the MIME type of the file.
-*   `content` (type: `str` if `binary` is `False`, otherwise `bytes`): the content of the file.
+*   `file_id` (*Str*, key): the ID of the file in Google Drive.
+*   `filename` (*Str*): the filename of the file, without the path, e.g. `"file1.md"`
+*   `mime_type` (*Str*): the MIME type of the file.
+*   `content` (*Str* if `binary` is `False`, otherwise *Bytes*): the content of the file.