> ## Documentation Index
> Fetch the complete documentation index at: https://docs.meibel.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Data Elements

> List, search, inspect, and update extracted data elements

Data elements are the individual items extracted from your datasource files during ingestion. Each element has an `id`, a `name`, a `media_type`, an optional `description`, and `metadata`. Agents can retrieve and cite them. This guide covers listing, searching, inspecting, and updating data elements.

## List data elements

Retrieve all data elements for a datasource. Results are paginated automatically by the SDK iterator.

<CodeGroup>
  ```python Python theme={null}
  import os
  from meibel import MeibelClient

  client = MeibelClient(api_key=os.environ["MEIBEL_API_KEY"])

  for element in client.datasources.data_elements.list(datasource_id="ds_123"):
      print(f"{element.id}: {element.name}")
  ```

  ```typescript TypeScript theme={null}
  import { MeibelClient } from 'meibel';

  const client = new MeibelClient({ apiKey: process.env.MEIBEL_API_KEY });

  for await (const element of client.datasources.dataElements.list('ds_123')) {
    console.log(`${element.id}: ${element.name}`);
  }
  ```

  ```go Go theme={null}
  import (
      "context"
      "fmt"
      "os"

      meibel "github.com/meibel-ai/meibel-go"
  )

  client := meibel.NewClient(meibel.WithAPIKey(os.Getenv("MEIBEL_API_KEY")))
  ctx := context.Background()

  iter := client.DataElements.ListDataElements(ctx, "ds_123", nil)
  for iter.Next(ctx) {
      element := iter.Item()
      content := element.Content
      if len(content) > 80 {
          content = content[:80] + "..."
      }
      fmt.Printf("%s: %s\n", element.ID, content)
  }
  if err := iter.Err(); err != nil {
      log.Fatal(err)
  }
  ```

  ```bash CLI theme={null}
  meibel data-elements list
  ```
</CodeGroup>

The iterator handles cursor-based pagination transparently. Each element includes `id`, `name`, `media_type`, `description`, and `metadata`.

## Get a data element

Retrieve the full details of a specific data element, including its name, media type, and metadata.

<CodeGroup>
  ```python Python theme={null}
  element = client.datasources.data_elements.get(
      data_element_id="de_456",
      datasource_id="ds_123",
  )

  print(element.id)
  print(element.name)
  print(element.media_type)
  print(element.metadata)
  ```

  ```typescript TypeScript theme={null}
  const element = await client.datasources.dataElements.get('de_456', 'ds_123');

  console.log(element.id);
  console.log(element.name);
  console.log(element.mediaType);
  console.log(element.metadata);
  ```

  ```go Go theme={null}
  element, err := client.DataElements.GetDataElement(ctx, "ds_123", "de_456")
  if err != nil {
      log.Fatal(err)
  }

  fmt.Println(element.ID)
  fmt.Println(element.Content)
  fmt.Println(element.SourceFile)
  fmt.Println(element.Metadata)
  ```

  ```bash CLI theme={null}
  meibel data-elements get de_456
  ```
</CodeGroup>

## Search data elements

Search across data elements within a datasource by filtering on the element name with a regular expression, optionally narrowing by media type. Matching elements are returned in `results.items`.

<CodeGroup>
  ```python Python theme={null}
  from meibel.models import DataElementSearchRequest

  results = client.datasources.data_elements.search(
      datasource_id="ds_123",
      body=DataElementSearchRequest(
          regex_filter="quarterly.*revenue",
      ),
  )

  for element in results.items:
      print(f"{element.id}: {element.name}")
  ```

  ```typescript TypeScript theme={null}
  const results = await client.datasources.dataElements.search('ds_123', {
    regexFilter: 'quarterly.*revenue',
  });

  for (const element of results.items) {
    console.log(`${element.id}: ${element.name}`);
  }
  ```

  ```go Go theme={null}
  results, err := client.DataElements.SearchDataElements(ctx, "ds_123", meibel.DataElementSearchRequest{
      RegexFilter: "quarterly.*revenue",
  }, nil)
  if err != nil {
      log.Fatal(err)
  }

  for _, result := range results {
      content := result.Content
      if len(content) > 100 {
          content = content[:100] + "..."
      }
      fmt.Printf("[%.2f] %s\n", result.Score, content)
  }
  ```

  ```bash CLI theme={null}
  meibel data-elements search --data '{
    "regex_filter": "quarterly.*revenue"
  }'
  ```
</CodeGroup>

Each entry in `results.items` is a data element with its `id`, `name`, `media_type`, and `metadata`. Page through larger result sets with `results.has_next` and `results.next_cursor`.

## Update a data element

Modify a data element's name, description, or metadata. This is useful for correcting extraction errors or enriching elements with additional context. See [Managing datasource metadata](/guides/datasource-metadata) for defining metadata fields and indexing them so you can filter and scope by them.

<CodeGroup>
  ```python Python theme={null}
  from meibel.models import UpdateDataElementRequest

  updated = client.datasources.data_elements.update(
      data_element_id="de_456",
      datasource_id="ds_123",
      body=UpdateDataElementRequest(
          description="Corrected figures for Q4 2025.",
          metadata={"reviewed": True, "reviewer": "finance-team"},
      ),
  )

  print(updated.id)
  print(updated.description)
  ```

  ```typescript TypeScript theme={null}
  const updated = await client.datasources.dataElements.update('de_456', 'ds_123', {
    description: 'Corrected figures for Q4 2025.',
    metadata: { reviewed: true, reviewer: 'finance-team' },
  });

  console.log(updated.id);
  console.log(updated.description);
  ```

  ```go Go theme={null}
  updated, err := client.DataElements.UpdateDataElement(ctx, "ds_123", "de_456", meibel.UpdateDataElementRequest{
      Content: "Corrected content with accurate figures for Q4 2025.",
      Metadata: map[string]interface{}{
          "reviewed": true,
          "reviewer": "finance-team",
      },
  })
  if err != nil {
      log.Fatal(err)
  }

  fmt.Println(updated.ID)
  fmt.Println(updated.Content)
  ```

  ```bash CLI theme={null}
  meibel data-elements update de_456 --data '{
    "content": "Corrected content with accurate figures for Q4 2025.",
    "metadata": {"reviewed": true, "reviewer": "finance-team"}
  }'
  ```
</CodeGroup>

<Note>
  Updates apply to a data element's `name`, `description`, and `metadata`. Metadata you set here can be indexed for filtering and scoping (see [Managing datasource metadata](/guides/datasource-metadata)).
</Note>