Skip to content
StudyFetch API

API References

Generating Materials

8 min read

Overview

The StudyFetch API allows you to generate various types of study materials using AI. You can:

  • Generate outlines for structured learning
  • Create comprehensive study notes
  • Build topic overviews
  • Generate concise summaries
  • Customize content length and education level
  • Organize generated materials into folders

Generate Material

Generate study materials from a topic. This method returns immediately with the material ID while generation happens asynchronously.

JavaScript

const material = await client.v1.materials.generate({
  name: 'Photosynthesis Study Notes',
  topic: 'Photosynthesis in plants',
  type: 'notes',
  context: 'Focus on light and dark reactions, chloroplast structure',
  level: 'college',
  length: 'medium',
  folderId: 'folder_123abc'
});

console.log('Material ID:', material._id);
console.log('Status:', material.status); // 'processing'

Python

material = client.v1.materials.generate(
    name="Photosynthesis Study Notes",
    topic="Photosynthesis in plants",
    type="notes",
    context="Focus on light and dark reactions, chloroplast structure",
    level="college",
    length="medium",
    folder_id="folder_123abc"
)

print(f"Material ID: {material._id}")
print(f"Status: {material.status}")  # 'processing'

Java

import com.studyfetch.javasdk.models.v1.materials.MaterialGenerateParams;
import com.studyfetch.javasdk.models.v1.materials.GeneratedMaterialResponse;

MaterialGenerateParams params = MaterialGenerateParams.builder()
    .name("Photosynthesis Study Notes")
    .topic("Photosynthesis in plants")
    .type(MaterialGenerateParams.Type.NOTES)
    .context("Focus on light and dark reactions, chloroplast structure")
    .level(MaterialGenerateParams.Level.COLLEGE)
    .length(MaterialGenerateParams.Length.MEDIUM)
    .folderId("folder_123abc")
    .build();

GeneratedMaterialResponse material = client.v1().materials().generate(params);

System.out.println("Material ID: " + material._id());
System.out.println("Status: " + material.status()); // 'processing'

// Access references if any were added
if (material.references().isPresent() && !material.references().get().isEmpty()) {
    System.out.println("References:");
    for (var reference : material.references().get()) {
        System.out.println("  - " + reference.title() + ": " + reference.url().orElse(""));
    }
}

C#

using StudyfetchSDK;
using StudyfetchSDK.Models.V1.Materials;
using System;
using System.Threading.Tasks;

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

        var material = await client.V1.Materials.Generate(new()
        {
            Name = "Photosynthesis Study Notes",
            Topic = "Photosynthesis in plants",
            Type = StudyfetchSDK.Models.V1.Materials.MaterialGenerateParamsProperties.Type.Notes,
            Context = "Focus on light and dark reactions, chloroplast structure",
            Level = StudyfetchSDK.Models.V1.Materials.MaterialGenerateParamsProperties.Level.College,
            Length = StudyfetchSDK.Models.V1.Materials.MaterialGenerateParamsProperties.Length.Medium,
            FolderID = "folder_123abc"
        });

        Console.WriteLine($"Material ID: {material._ID}");
        Console.WriteLine($"Status: {material.Status}"); // 'processing'
    }
}

Generate Parameters

name

string · required

Name for the generated material

topic

string · required

Topic or context to generate material from

type

string · required

Type of material to generate:

  • outline - Structured hierarchical breakdown
  • overview - High-level introduction to topic
  • notes - Detailed study notes with explanations
  • summary - Concise summary of key points

context

string

Additional context or details about the topic

folderId

string

Target folder ID to organize the material

length

string · default: medium

Length of the generated content:

  • short - Brief content (1-2 pages)
  • medium - Standard length (3-5 pages)
  • long - Comprehensive content (6+ pages)

level

string · default: college

Target education level:

  • high_school - Basic concepts, simpler language
  • college - Standard academic level
  • professional - Advanced, technical content

Response

{
  "_id": "material_789ghi",
  "name": "Photosynthesis Study Notes",
  "type": "notes",
  "contentType": "generated",
  "topic": "Photosynthesis in plants",
  "generationType": "notes",
  "status": "processing",
  "content": null,
  "wordCount": 0,
  "organizationId": "org_456def",
  "folderId": "folder_123abc",
  "level": "college",
  "length": "medium",
  "references": [],
  "createdAt": "2024-01-20T14:30:00Z",
  "updatedAt": "2024-01-20T14:30:00Z"
}

Generate and Process Material

Generate materials and wait for processing to complete. This method polls until the material is ready or times out.

JavaScript

const material = await client.v1.materials.generateAndProcess({
  name: 'Complete Biology Notes',
  topic: 'Cell division and mitosis',
  type: 'notes',
  level: 'college',
  length: 'long',
  pollIntervalMs: 2000,  // Check every 2 seconds
  timeoutMs: 300000      // Wait up to 5 minutes
});

console.log('Material ready!');
console.log('Word count:', material.metadata);
console.log('Content preview:', material.content.text);

Python

material = client.v1.materials.generate_and_process(
    name="Complete Biology Notes",
    topic="Cell division and mitosis",
    type="notes",
    level="college",
    length="long",
    poll_interval_ms=2000,  # Check every 2 seconds
    timeout_ms=300000       # Wait up to 5 minutes
)

print("Material ready!")
print(f"Word count: {material.word_count}")
print(f"Content preview: {material.content[:200]}")

Java

import com.studyfetch.javasdk.models.v1.materials.MaterialGenerateAndProcessParams;

MaterialGenerateAndProcessParams params = 
    MaterialGenerateAndProcessParams.builder()
        .name("Complete Biology Notes")
        .topic("Cell division and mitosis")
        .type(MaterialGenerateAndProcessParams.Type.NOTES)
        .level(MaterialGenerateAndProcessParams.Level.COLLEGE)
        .length(MaterialGenerateAndProcessParams.Length.LONG)
        .pollIntervalMs(2000.0)  // Check every 2 seconds
        .timeoutMs(300000.0)     // Wait up to 5 minutes
        .build();

GeneratedMaterialResponse material = client.v1().materials()
    .generateAndProcess(params);

System.out.println("Material ready!");
System.out.println("Material ID: " + material._id());
System.out.println("Material Name: " + material.name());

// Access references if any were added
if (material.references().isPresent() && !material.references().get().isEmpty()) {
    System.out.println("References:");
    for (var reference : material.references().get()) {
        System.out.println("  - " + reference.title() + ": " + reference.url().orElse(""));
    }
}

C#

using StudyfetchSDK;
using StudyfetchSDK.Models.V1.Materials;
using System;
using System.Threading.Tasks;

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

        var material = await client.V1.Materials.GenerateAndProcess(new()
        {
            Name = "Complete Biology Notes",
            Topic = "Cell division and mitosis",
            Type = StudyfetchSDK.Models.V1.Materials.MaterialGenerateAndProcessParamsProperties.Type.Notes,
            Level = StudyfetchSDK.Models.V1.Materials.MaterialGenerateAndProcessParamsProperties.Level.College,
            Length = StudyfetchSDK.Models.V1.Materials.MaterialGenerateAndProcessParamsProperties.Length.Long,
            PollIntervalMs = 2000,  // Check every 2 seconds
            TimeoutMs = 300000      // Wait up to 5 minutes
        });

        Console.WriteLine("Material ready!");
        Console.WriteLine($"Material ID: {material._ID}");
        Console.WriteLine($"Material Name: {material.Name}");
    }
}

Generate and Process Parameters

All parameters from generate() plus:

pollIntervalMs

integer · default: 2000

Polling interval in milliseconds to check if material is ready

timeoutMs

integer · default: 300000

Maximum time to wait for processing in milliseconds (default: 5 minutes)

Response

{
  "_id": "material_789ghi",
  "name": "Complete Biology Notes",
  "type": "notes",
  "contentType": "generated",
  "topic": "Cell division and mitosis",
  "generationType": "notes",
  "status": "completed",
  "content": "# Cell Division and Mitosis\n\n## Introduction\n\nCell division is a fundamental process...",
  "wordCount": 2450,
  "organizationId": "org_456def",
  "folderId": null,
  "level": "college",
  "length": "long",
  "references": [],
  "createdAt": "2024-01-20T14:30:00Z",
  "updatedAt": "2024-01-20T14:31:45Z"
}

Complete Workflow Example

Here's a complete example of generating and organizing study materials for a course:

JavaScript

// 1. Create a folder for the course
const courseFolder = await client.v1.folders.create({
  name: 'Biology 101 - Spring 2024'
});

// 2. Generate course outline
const outline = await client.v1.materials.generateAndProcess({
  name: 'Biology 101 Course Outline',
  topic: 'Introduction to Biology for first-year students',
  type: 'outline',
  folderId: courseFolder._id,
  level: 'college',
  length: 'long'
});

console.log('Course outline generated:', outline.name);

// 3. Generate chapter materials
const chapters = [
  { name: 'Cell Biology', topic: 'Cell structure, organelles, and functions' },
  { name: 'Genetics', topic: 'DNA, RNA, heredity, and gene expression' },
  { name: 'Evolution', topic: 'Natural selection, speciation, and evidence' }
];

const chapterMaterials = await Promise.all(
  chapters.map(chapter => 
    client.v1.materials.generate({
      name: `${chapter.name} - Study Notes`,
      topic: chapter.topic,
      type: 'notes',
      folderId: courseFolder._id,
      level: 'college',
      length: 'medium',
      context: 'Include diagrams descriptions and key terminology'
    })
  )
);

console.log(`Generated ${chapterMaterials.length} chapter materials`);

// 4. Generate quick summaries for review
const summaries = await Promise.all(
  chapters.map(chapter =>
    client.v1.materials.generateAndProcess({
      name: `${chapter.name} - Quick Review`,
      topic: chapter.topic,
      type: 'summary',
      folderId: courseFolder._id,
      level: 'college',
      length: 'short'
    })
  )
);

// 5. List all materials in the folder
const allMaterials = await client.v1.materials.list({
  folderId: courseFolder._id
});

console.log('\nCourse materials:');
allMaterials.materials?.forEach(material => {
  console.log(`- ${material.name} (${material.contentType})`);
});

Python

# 1. Create a folder for the course
course_folder = client.v1.folders.create(
    name="Biology 101 - Spring 2024"
)

# 2. Generate course outline
outline = client.v1.materials.generate_and_process(
    name="Biology 101 Course Outline",
    topic="Introduction to Biology for first-year students",
    type="outline",
    folder_id=course_folder._id,
    level="college",
    length="long"
)

print(f"Course outline generated: {outline.name}")

# 3. Generate chapter materials
chapters = [
    {"name": "Cell Biology", "topic": "Cell structure, organelles, and functions"},
    {"name": "Genetics", "topic": "DNA, RNA, heredity, and gene expression"},
    {"name": "Evolution", "topic": "Natural selection, speciation, and evidence"}
]

chapter_materials = []
for chapter in chapters:
    material = client.v1.materials.generate(
        name=f"{chapter['name']} - Study Notes",
        topic=chapter["topic"],
        type="notes",
        folder_id=course_folder._id,
        level="college",
        length="medium",
        context="Include diagrams descriptions and key terminology"
    )
    chapter_materials.append(material)

print(f"Generated {len(chapter_materials)} chapter materials")

# 4. Generate quick summaries for review
summaries = []
for chapter in chapters:
    summary = client.v1.materials.generate_and_process(
        name=f"{chapter['name']} - Quick Review",
        topic=chapter["topic"],
        type="summary",
        folder_id=course_folder._id,
        level="college",
        length="short"
    )
    summaries.append(summary)

# 5. List all materials in the folder
all_materials = client.v1.materials.list(
    folder_id=course_folder._id
)

print("\nCourse materials:")
for material in all_materials:
    material_type = material.generation_type or material.content_type
    print(f"- {material.name} ({material_type})")

Java

import com.studyfetch.javasdk.client.StudyfetchSdkClient;
import com.studyfetch.javasdk.client.okhttp.StudyfetchSdkOkHttpClient;
import com.studyfetch.javasdk.models.v1.materials.*;
import com.studyfetch.javasdk.models.v1.folders.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;

// 1. Create a folder for the course
FolderCreateResponse courseFolder = client.v1().folders().create(
    FolderCreateParams.builder()
        .name("Biology 101 - Spring 2024")
        .build()
);

// 2. Generate course outline
MaterialGenerateAndProcessParams outlineParams = 
    MaterialGenerateAndProcessParams.builder()
        .name("Biology 101 Course Outline")
        .topic("Introduction to Biology for first-year students")
        .type(MaterialGenerateAndProcessParams.Type.OUTLINE)
        .folderId(courseFolder._id())
        .level(MaterialGenerateAndProcessParams.Level.COLLEGE)
        .length(MaterialGenerateAndProcessParams.Length.LONG)
        .build();

GeneratedMaterialResponse outline = client.v1().materials()
    .generateAndProcess(outlineParams);

System.out.println("Course outline generated: " + outline.name());

// 3. Generate chapter materials
class Chapter {
    String name;
    String topic;
    
    Chapter(String name, String topic) {
        this.name = name;
        this.topic = topic;
    }
}

List<Chapter> chapters = List.of(
    new Chapter("Cell Biology", "Cell structure, organelles, and functions"),
    new Chapter("Genetics", "DNA, RNA, heredity, and gene expression"),
    new Chapter("Evolution", "Natural selection, speciation, and evidence")
);

List<GeneratedMaterialResponse> chapterMaterials = new ArrayList<>();
for (Chapter chapter : chapters) {
    MaterialGenerateParams params = MaterialGenerateParams.builder()
        .name(chapter.name + " - Study Notes")
        .topic(chapter.topic)
        .type(MaterialGenerateParams.Type.NOTES)
        .folderId(courseFolder._id())
        .level(MaterialGenerateParams.Level.COLLEGE)
        .length(MaterialGenerateParams.Length.MEDIUM)
        .context("Include diagrams descriptions and key terminology")
        .build();
    
    GeneratedMaterialResponse material = client.v1().materials().generate(params);
    chapterMaterials.add(material);
}

System.out.println("Generated " + chapterMaterials.size() + " chapter materials");

// 4. Generate quick summaries for review
List<GeneratedMaterialResponse> summaries = new ArrayList<>();
for (Chapter chapter : chapters) {
    MaterialGenerateAndProcessParams summaryParams = 
        MaterialGenerateAndProcessParams.builder()
            .name(chapter.name + " - Quick Review")
            .topic(chapter.topic)
            .type(MaterialGenerateAndProcessParams.Type.SUMMARY)
            .folderId(courseFolder._id())
            .level(MaterialGenerateAndProcessParams.Level.COLLEGE)
            .length(MaterialGenerateAndProcessParams.Length.SHORT)
            .build();
    
    GeneratedMaterialResponse summary = client.v1().materials()
        .generateAndProcess(summaryParams);
    summaries.add(summary);
}

// 5. List all materials in the folder
MaterialListParams listParams = MaterialListParams.builder()
    .folderId(courseFolder._id())
    .build();
MaterialListResponse allMaterials = client.v1().materials().list(listParams);

System.out.println("\nCourse materials:");
for (MaterialResponse material : allMaterials.materials().orElse(Collections.emptyList())) {
    System.out.println("- " + material.name() + " (" + material.contentType() + ")");
}

C#

using StudyfetchSDK;
using StudyfetchSDK.Models.V1.Folders;
using StudyfetchSDK.Models.V1.Materials;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

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

        // 1. Create a folder for the course
        var courseFolder = await client.V1.Folders.Create(new()
        {
            Name = "Biology 101 - Spring 2024"
        });

        // 2. Generate course outline
        var outline = await client.V1.Materials.GenerateAndProcess(new()
        {
            Name = "Biology 101 Course Outline",
            Topic = "Introduction to Biology for first-year students",
            Type = StudyfetchSDK.Models.V1.Materials.MaterialGenerateAndProcessParamsProperties.Type.Outline,
            FolderID = courseFolder._ID,
            Level = StudyfetchSDK.Models.V1.Materials.MaterialGenerateAndProcessParamsProperties.Level.College,
            Length = StudyfetchSDK.Models.V1.Materials.MaterialGenerateAndProcessParamsProperties.Length.Long
        });

        Console.WriteLine($"Course outline generated: {outline.Name}");

        // 3. Generate chapter materials
        var chapters = new[]
        {
            new { Name = "Cell Biology", Topic = "Cell structure, organelles, and functions" },
            new { Name = "Genetics", Topic = "DNA, RNA, heredity, and gene expression" },
            new { Name = "Evolution", Topic = "Natural selection, speciation, and evidence" }
        };

        var chapterMaterials = new List<MaterialGenerateResponse>();
        foreach (var chapter in chapters)
        {
            var material = await client.V1.Materials.Generate(new()
            {
                Name = $"{chapter.Name} - Study Notes",
                Topic = chapter.Topic,
                Type = StudyfetchSDK.Models.V1.Materials.MaterialGenerateParamsProperties.Type.Notes,
                FolderID = courseFolder._ID,
                Level = StudyfetchSDK.Models.V1.Materials.MaterialGenerateParamsProperties.Level.College,
                Length = StudyfetchSDK.Models.V1.Materials.MaterialGenerateParamsProperties.Length.Medium,
                Context = "Include diagrams descriptions and key terminology"
            });
            chapterMaterials.Add(material);
        }

        Console.WriteLine($"Generated {chapterMaterials.Count} chapter materials");

        // 4. Generate quick summaries for review
        var summaries = new List<MaterialGenerateAndProcessResponse>();
        foreach (var chapter in chapters)
        {
            var summary = await client.V1.Materials.GenerateAndProcess(new()
            {
                Name = $"{chapter.Name} - Quick Review",
                Topic = chapter.Topic,
                Type = StudyfetchSDK.Models.V1.Materials.MaterialGenerateAndProcessParamsProperties.Type.Summary,
                FolderID = courseFolder._ID,
                Level = StudyfetchSDK.Models.V1.Materials.MaterialGenerateAndProcessParamsProperties.Level.College,
                Length = StudyfetchSDK.Models.V1.Materials.MaterialGenerateAndProcessParamsProperties.Length.Short
            });
            summaries.Add(summary);
        }

        // 5. List all materials in the folder
        var allMaterials = await client.V1.Materials.List(new()
        {
            FolderID = courseFolder._ID
        });

        Console.WriteLine("\nCourse materials:");
        foreach (var material in allMaterials.Materials ?? [])
        {
            Console.WriteLine($"- {material.Name} ({material.ContentType})");
        }
    }
}
PreviousFoldersNextManaging Materials