> ## 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

Data elements are the individual pieces of knowledge extracted from your datasource files during ingestion. Each element represents a discrete chunk of content (a paragraph, table, figure, or section) that agents can retrieve and cite. 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.data_elements.list_data_elements(datasource_id="ds_123"):
      print(f"{element.id}: {element.content[:80]}...")
  ```

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

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

  for await (const element of client.dataElements.listDataElements('ds_123')) {
    console.log(`${element.id}: ${element.content.slice(0, 80)}...`);
  }
  ```

  ```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`, `content`, `metadata`, and source file information.

## Get a data element

Retrieve the full details of a specific data element, including its content, metadata, and source location.

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

  print(element.id)
  print(element.content)
  print(element.source_file)
  print(element.metadata)
  ```

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

  console.log(element.id);
  console.log(element.content);
  console.log(element.sourceFile);
  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 using semantic or keyword queries. This is useful for previewing what an agent would retrieve for a given question.

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

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

  for result in results:
      print(f"[{result.score:.2f}] {result.content[:100]}...")
  ```

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

  for (const result of results) {
    console.log(`[${result.score.toFixed(2)}] ${result.content.slice(0, 100)}...`);
  }
  ```

  ```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 result includes a relevance `score`, the element `content`, and its `id` for further inspection. Higher scores indicate stronger matches.

## Update a data element

Modify a data element's content or metadata. This is useful for correcting extraction errors or enriching elements with additional context.

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

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

  print(updated.id)
  print(updated.content)
  ```

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

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

  ```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>
  Updating a data element's content triggers re-embedding so that search results reflect the new content. This happens automatically in the background.
</Note>