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

# Search Materials

> Search through your materials using semantic search powered by RAG

## Overview

The Materials API includes powerful semantic search capabilities using Retrieval-Augmented Generation (RAG). This allows you to:

* Search materials by meaning, not just keywords
* Find relevant content across all your materials
* Get contextual results with relevance scores
* Search within specific materials or folders

## How It Works

1. **Automatic Indexing** - When materials are uploaded, they're automatically processed:
   * Text is extracted (OCR for PDFs, transcription for audio/video)
   * Content is split into chunks
   * Vector embeddings are generated
   * Embeddings are stored in a vector database

2. **Semantic Search** - When you search:
   * Your query is converted to a vector embedding
   * Similar content is found using vector similarity
   * Results are ranked by relevance

## Search Materials

Perform a semantic search across all your materials.

<CodeGroup>
  ```javascript JavaScript theme={null}
  const searchResults = await client.v1.materials.search({
    query: 'What is photosynthesis and how does it work?',
    topK: 5 // Number of results to return
  });

  searchResults.results.forEach(result => {
    console.log(`Score: ${result.score}`);
    console.log(`Material: ${result.material?.name}`);
    console.log(`Chunk: ${result.text.substring(0, 200)}...`);
    console.log('---');
  });
  ```

  ```python Python theme={null}
  search_results = client.v1.materials.search(
      query="What is photosynthesis and how does it work?",
      top_k=5  # Number of results to return
  )

  for result in search_results.results:
      print(f"Score: {result.score}")
      print(f"Material: {result.material.name}")
      print(f"Chunk: {result.text[:200]}...")
      print("---")
  ```

  ```java Java theme={null}
  import com.studyfetch.javasdk.models.v1.materials.MaterialSearchParams;
  import com.studyfetch.javasdk.models.v1.materials.MaterialSearchResponse;

  MaterialSearchParams params = MaterialSearchParams.builder()
      .query("What is photosynthesis and how does it work?")
      .topK(5)  // Number of results to return
      .build();

  MaterialSearchResponse searchResults = client.v1().materials().search(params);

  for (MaterialSearchResponse.Result result : searchResults.results()) {
      System.out.println("Score: " + result.score());
      System.out.println("Material: " + result.material());
      System.out.println("Chunk: " + 
          result.text().substring(0, Math.min(200, result.text().length())) + "...");
      System.out.println("---");
  }
  ```

  ```csharp C# theme={null}
  using StudyfetchSDK;
  using StudyfetchSDK.Models.V1.Materials;
  using System;
  using System.Threading.Tasks;

  public class SearchMaterials
  {
      public static async Task Search()
      {
          StudyfetchSDKClient client = new()
          {
              APIKey = Environment.GetEnvironmentVariable("STUDYFETCH_API_KEY"),
              BaseUrl = new Uri("https://studyfetchapi.com")
          };

          var searchResults = await client.V1.Materials.Search(new MaterialSearchParams()
          {
              Query = "What is photosynthesis and how does it work?",
              TopK = 5 // Number of results to return
          });

          foreach (var result in searchResults.Results)
          {
              Console.WriteLine($"Score: {result.Score}");
              Console.WriteLine($"Material: {result.Material.Name}");
              Console.WriteLine($"Chunk: {result.Text.Substring(0, Math.Min(200, result.Text.Length))}...");
              Console.WriteLine("---");
          }
      }
  }
  ```
</CodeGroup>

## Search Response Format

```json theme={null}
{
  "query": "What is photosynthesis and how does it work?",
  "totalResults": 5,
  "results": [
    {
      "score": 0.92,
      "text": "Photosynthesis is the process by which plants convert light energy into chemical energy...",
      "chunkIndex": 3,
      "material": {
        "id": "mat_123abc",
        "name": "Biology Chapter 3 - Plant Processes",
        "contentType": "pdf",
        "references": [
          {
            "title": "Plant Biology Handbook",
            "url": "https://example.com/handbook"
          }
        ]
      }
    },
    {
      "score": 0.87,
      "text": "The light-dependent reactions of photosynthesis occur in the thylakoid membranes...",
      "chunkIndex": 5,
      "material": {
        "id": "mat_456def",
        "name": "Plant Biology Textbook",
        "contentType": "pdf",
        "references": [
          {
            "title": "Advanced Plant Science",
            "url": "https://example.com/advanced-plant-science"
          }
        ]
      }
    }
  ]
}
```

## Advanced Search Options

### Search with More Results

<CodeGroup>
  ```javascript JavaScript theme={null}
  // Get more results for comprehensive coverage
  const results = await client.v1.materials.search({
    query: 'cellular respiration and ATP production',
    topK: 20 // Get top 20 results
  });

  console.log(`Found ${results.totalResults} relevant chunks`);
  ```

  ```python Python theme={null}
  # Get more results for comprehensive coverage
  results = client.v1.materials.search(
      query="cellular respiration and ATP production",
      top_k=20  # Get top 20 results
  )

  print(f"Found {results.total_results} relevant chunks")
  ```

  ```java Java theme={null}
  // Get more results for comprehensive coverage
  MaterialSearchParams params = MaterialSearchParams.builder()
      .query("cellular respiration and ATP production")
      .topK(20)  // Get top 20 results
      .build();

  MaterialSearchResponse results = client.v1().materials().search(params);

  System.out.println("Found " + results.results().size() + " relevant chunks");
  ```

  ```csharp C# theme={null}
  using StudyfetchSDK;
  using StudyfetchSDK.Models.V1.Materials;
  using System;
  using System.Threading.Tasks;

  public class SearchWithMoreResults
  {
      public static async Task SearchMore()
      {
          StudyfetchSDKClient client = new()
          {
              APIKey = Environment.GetEnvironmentVariable("STUDYFETCH_API_KEY"),
              BaseUrl = new Uri("https://studyfetchapi.com")
          };

          // Get more results for comprehensive coverage
          var results = await client.V1.Materials.Search(new MaterialSearchParams()
          {
              Query = "cellular respiration and ATP production",
              TopK = 20 // Get top 20 results
          });

          Console.WriteLine($"Found {results.TotalResults} relevant chunks");
      }
  }
  ```
</CodeGroup>

### Filter by Material Type

While the current API doesn't support filtering in the search endpoint, you can filter results after retrieval:

<CodeGroup>
  ```javascript JavaScript theme={null}
  const searchResults = await client.v1.materials.search({
    query: 'DNA replication process',
    topK: 10
  });

  // Filter for only PDF results
  const pdfResults = searchResults.results.filter(
    result => result.material?.contentType === 'pdf'
  );

  console.log(`Found ${pdfResults.length} results in PDFs`);
  ```

  ```python Python theme={null}
  search_results = client.v1.materials.search(
      query="DNA replication process",
      top_k=10
  )

  # Filter for only PDF results
  pdf_results = [
      result for result in search_results.results 
      if result.material.content_type == "pdf"
  ]

  print(f"Found {len(pdf_results)} results in PDFs")
  ```

  ```java Java theme={null}
  import com.studyfetch.javasdk.models.v1.materials.MaterialSearchParams;
  import com.studyfetch.javasdk.models.v1.materials.MaterialSearchResponse;
  import java.util.List;
  import java.util.stream.Collectors;

  MaterialSearchResponse searchResults = client.v1().materials().search(
      MaterialSearchParams.builder()
          .query("DNA replication process")
          .topK(10)
          .build()
  );

  // Filter for only PDF results
  List<MaterialSearchResponse.Result> pdfResults = searchResults.results().stream()
      .filter(result -> result.material().isPresent() && 
                       "pdf".equals(result.material().get().contentType()))
      .collect(Collectors.toList());

  System.out.println("Found " + pdfResults.size() + " results in PDFs");
  ```

  ```csharp C# theme={null}
  using StudyfetchSDK;
  using StudyfetchSDK.Models.V1.Materials;
  using System;
  using System.Linq;
  using System.Threading.Tasks;

  public class FilterSearchResults
  {
      public static async Task FilterByType()
      {
          StudyfetchSDKClient client = new()
          {
              APIKey = Environment.GetEnvironmentVariable("STUDYFETCH_API_KEY"),
              BaseUrl = new Uri("https://studyfetchapi.com")
          };

          var searchResults = await client.V1.Materials.Search(new MaterialSearchParams()
          {
              Query = "DNA replication process",
              TopK = 10
          });

          // Filter for only PDF results
          var pdfResults = searchResults.Results
              .Where(result => result.Material.ContentType == "pdf")
              .ToList();

          Console.WriteLine($"Found {pdfResults.Count} results in PDFs");
      }
  }
  ```
</CodeGroup>