使用已保存的配置

已保存的配置让你只需定义一次解析与抽取设置 —— 在 LlamaCloud 界面里或通过 API —— 之后创建抽取任务时按 ID 引用即可。下面这些情形它很有用：

统一：让团队用同一份配置做抽取
简化：用一个 ID 取代内联配置来创建任务
解耦：把解析设置与抽取设置分开，自由搭配
迭代：在界面 playground 里调好，再用同样的设置做程序化调用

概念

与抽取相关的已保存配置有两类：

配置类型	产品类型	管什么
解析配置	`parse_v2`	文档在抽取之前怎么被解析（档位、选项）
抽取配置	`extract_v2`	完整的抽取设置：schema、档位、抽取目标，以及可选地对某份解析配置的引用

两者都通过Product Configurations API（/api/v1/beta/configurations）管理。

version 可填形如 2.5 的版本名，或填 latest。已保存配置会按你给的值原样保留。见版本。

提示

最省事的创建方式是用 LlamaCloud 界面。打开 Extract playground、配好设置，在 Build 标签的 Configs 菜单里选 Save as config…。Parse playground 也能把自己的设置存成配置。之后按下例用配置 ID 做程序化调用。

通过 API 创建配置

创建解析配置

解析配置把你的 LlamaParse 设置存下来，以便在多个抽取任务之间复用。

Python
TypeScript
Go
Java
CLI
cURL

import os
from llama_cloud import LlamaCloud

client = LlamaCloud(api_key=os.environ["LLAMA_CLOUD_API_KEY"])

# Create a saved parse configuration
parse_config = client.configurations.create(
    name="High Quality Parse",
    parameters={
        "product_type": "parse_v2",
        "version": "latest",
        "tier": "agentic",
    },
)

print(f"Parse config ID: {parse_config.id}")
# e.g. "cfg-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"

import LlamaCloud from '@llamaindex/llama-cloud';

const client = new LlamaCloud({
  apiKey: process.env.LLAMA_CLOUD_API_KEY!,
});

// Create a saved parse configuration
const parseConfig = await client.configurations.create({
  name: 'High Quality Parse',
  parameters: {
    product_type: 'parse_v2',
    version: 'latest',
    tier: 'agentic',
  },
});

console.log(`Parse config ID: ${parseConfig.id}`);

package main

import (
    "context"
    "fmt"
    "log"

    llamacloud "github.com/run-llama/llama-parse-go"
)

func main() {
    ctx := context.Background()
    client := llamacloud.NewClient()

    // Create a saved parse configuration
    parseConfig, err := client.Configurations.New(ctx, llamacloud.ConfigurationNewParams{
        ConfigurationCreate: llamacloud.ConfigurationCreateParam{
            Name: "High Quality Parse",
            Parameters: llamacloud.ConfigurationCreateParametersUnionParam{
                OfParseV2: &llamacloud.ParseV2Parameters{
                    Tier:    llamacloud.ParseV2ParametersTierAgentic,
                    Version: llamacloud.ParseV2ParametersVersionLatest,
                },
            },
        },
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Parse config ID: %s\n", parseConfig.ID)
}

import ai.llamaindex.llamacloud.client.LlamaCloudClient;
import ai.llamaindex.llamacloud.client.okhttp.LlamaCloudOkHttpClient;
import ai.llamaindex.llamacloud.models.configurations.ConfigurationCreate;
import ai.llamaindex.llamacloud.models.configurations.ConfigurationCreateParams;
import ai.llamaindex.llamacloud.models.configurations.ConfigurationResponse;
import ai.llamaindex.llamacloud.models.configurations.ParseV2Parameters;

LlamaCloudClient client = LlamaCloudOkHttpClient.fromEnv();

// Create a saved parse configuration
ConfigurationResponse parseConfig = client.configurations().create(
        ConfigurationCreateParams.builder()
                .configurationCreate(
                        ConfigurationCreate.builder()
                                .name("High Quality Parse")
                                .parameters(
                                        ParseV2Parameters.builder()
                                                .tier(ParseV2Parameters.Tier.AGENTIC)
                                                .version(ParseV2Parameters.Version.LATEST)
                                                .build())
                                .build())
                .build());

System.out.println("Parse config ID: " + parseConfig.id());

终端窗口

# llp reads LLAMA_CLOUD_API_KEY from the environment.
# Create a saved parse configuration
PARSE_CONFIG_ID=$(llp configurations create \
  --name "High Quality Parse" \
  --parameters '{"product_type": "parse_v2", "version": "latest", "tier": "agentic"}' \
  | jq -r '.id')

echo "Parse config ID: $PARSE_CONFIG_ID"

终端窗口

curl -X 'POST' \
  'https://api.cloud.llamaindex.ai/api/v1/beta/configurations?project_id={PROJECT_ID}' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $LLAMA_CLOUD_API_KEY" \
  -d '{
    "name": "High Quality Parse",
    "parameters": {
      "product_type": "parse_v2",
      "version": "latest",
      "tier": "agentic"
    }
  }'

创建抽取配置

抽取配置保存你的 schema、抽取档位与其他设置。你还可以在它内部引用一份已保存的解析配置。

Python
TypeScript
Go
Java
CLI
cURL

from pydantic import BaseModel, Field
from typing import Optional

# Define your extraction schema
class InvoiceData(BaseModel):
    vendor_name: str = Field(description="Name of the vendor or supplier")
    invoice_number: str = Field(description="Unique invoice identifier")
    total_amount: float = Field(description="Total amount due")
    currency: str = Field(description="Currency code (e.g. USD, EUR)")
    due_date: Optional[str] = Field(None, description="Payment due date")

# Create a saved extract configuration that references the parse config
extract_config = client.configurations.create(
    name="Invoice Extraction",
    parameters={
        "product_type": "extract_v2",
        "parse_config_id": parse_config.id,   # Reference the parse config
        "data_schema": InvoiceData.model_json_schema(),
        "extraction_target": "per_doc",
        "tier": "agentic",
        "version": "2.5",
        "cite_sources": True,
    },
)

print(f"Extract config ID: {extract_config.id}")

// Define your extraction schema as a JSON Schema literal
const invoiceSchema = {
  type: 'object',
  properties: {
    vendor_name: { type: 'string', description: 'Name of the vendor or supplier' },
    invoice_number: { type: 'string', description: 'Unique invoice identifier' },
    total_amount: { type: 'number', description: 'Total amount due' },
    currency: { type: 'string', description: 'Currency code (e.g. USD, EUR)' },
    due_date: { type: 'string', description: 'Payment due date', nullable: true },
  },
  required: ['vendor_name', 'invoice_number', 'total_amount', 'currency'],
};

// Create a saved extract configuration that references the parse config
const extractConfig = await client.configurations.create({
  name: 'Invoice Extraction',
  parameters: {
    product_type: 'extract_v2',
    parse_config_id: parseConfig.id,
    data_schema: invoiceSchema,
    extraction_target: 'per_doc',
    tier: 'agentic',
    version: '2.5',
    cite_sources: true,
  },
});

console.log(`Extract config ID: ${extractConfig.id}`);

// Define your extraction schema as a JSON Schema literal
dataSchema := map[string]*llamacloud.ExtractV2ParametersDataSchemaUnion{
    "type": {OfString: llamacloud.String("object")},
    "properties": {OfAnyMap: map[string]any{
        "vendor_name":    map[string]any{"type": "string", "description": "Name of the vendor or supplier"},
        "invoice_number": map[string]any{"type": "string", "description": "Unique invoice identifier"},
        "total_amount":   map[string]any{"type": "number", "description": "Total amount due"},
        "currency":       map[string]any{"type": "string", "description": "Currency code (e.g. USD, EUR)"},
        "due_date":       map[string]any{"type": "string", "description": "Payment due date", "nullable": true},
    }},
    "required": {OfAnyArray: []any{"vendor_name", "invoice_number", "total_amount", "currency"}},
}

// Create a saved extract configuration that references the parse config
extractConfig, err := client.Configurations.New(ctx, llamacloud.ConfigurationNewParams{
    ConfigurationCreate: llamacloud.ConfigurationCreateParam{
        Name: "Invoice Extraction",
        Parameters: llamacloud.ConfigurationCreateParametersUnionParam{
            OfExtractV2: &llamacloud.ExtractV2Parameters{
                ParseConfigID:    llamacloud.String(parseConfig.ID),
                DataSchema:       dataSchema,
                ExtractionTarget: llamacloud.ExtractV2ParametersExtractionTargetPerDoc,
                Tier:             llamacloud.ExtractV2ParametersTierAgentic,
                Version:          llamacloud.String("2.5"),
                CiteSources:      llamacloud.Bool(true),
            },
        },
    },
})
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Extract config ID: %s\n", extractConfig.ID)

import ai.llamaindex.llamacloud.core.JsonValue;
import ai.llamaindex.llamacloud.models.configurations.ExtractV2Parameters;
import java.util.List;
import java.util.Map;

// Define your extraction schema as a JSON Schema literal
ExtractV2Parameters.DataSchema dataSchema = ExtractV2Parameters.DataSchema.builder()
        .putAdditionalProperty("type", JsonValue.from("object"))
        .putAdditionalProperty("properties", JsonValue.from(Map.of(
                "vendor_name", Map.of("type", "string", "description", "Name of the vendor or supplier"),
                "invoice_number", Map.of("type", "string", "description", "Unique invoice identifier"),
                "total_amount", Map.of("type", "number", "description", "Total amount due"),
                "currency", Map.of("type", "string", "description", "Currency code (e.g. USD, EUR)"),
                "due_date", Map.of("type", "string", "description", "Payment due date", "nullable", true))))
        .putAdditionalProperty("required", JsonValue.from(List.of("vendor_name", "invoice_number", "total_amount", "currency")))
        .build();

// Create a saved extract configuration that references the parse config
ConfigurationResponse extractConfig = client.configurations().create(
        ConfigurationCreateParams.builder()
                .configurationCreate(
                        ConfigurationCreate.builder()
                                .name("Invoice Extraction")
                                .parameters(
                                        ExtractV2Parameters.builder()
                                                .parseConfigId(parseConfig.id())
                                                .dataSchema(dataSchema)
                                                .extractionTarget(ExtractV2Parameters.ExtractionTarget.PER_DOC)
                                                .tier(ExtractV2Parameters.Tier.AGENTIC)
                                                .version("2.5")
                                                .citeSources(true)
                                                .build())
                                .build())
                .build());

System.out.println("Extract config ID: " + extractConfig.id());

终端窗口

DATA_SCHEMA='{
  "type": "object",
  "properties": {
    "vendor_name": {"type": "string", "description": "Name of the vendor or supplier"},
    "invoice_number": {"type": "string", "description": "Unique invoice identifier"},
    "total_amount": {"type": "number", "description": "Total amount due"},
    "currency": {"type": "string", "description": "Currency code (e.g. USD, EUR)"},
    "due_date": {"type": "string", "description": "Payment due date", "nullable": true}
  },
  "required": ["vendor_name", "invoice_number", "total_amount", "currency"]
}'

# Create a saved extract configuration that references the parse config
EXTRACT_CONFIG_ID=$(llp configurations create \
  --name "Invoice Extraction" \
  --parameters "{\"product_type\": \"extract_v2\", \"parse_config_id\": \"$PARSE_CONFIG_ID\", \"data_schema\": $DATA_SCHEMA, \"extraction_target\": \"per_doc\", \"tier\": \"agentic\", \"version\": \"2.5\", \"cite_sources\": true}" \
  | jq -r '.id')

echo "Extract config ID: $EXTRACT_CONFIG_ID"

终端窗口

curl -X 'POST' \
  'https://api.cloud.llamaindex.ai/api/v1/beta/configurations?project_id={PROJECT_ID}' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $LLAMA_CLOUD_API_KEY" \
  -d '{
    "name": "Invoice Extraction",
    "parameters": {
      "product_type": "extract_v2",
        "parse_config_id": "{PARSE_CONFIG_ID}",
      "data_schema": {
        "type": "object",
        "properties": {
          "vendor_name": {"type": "string", "description": "Name of the vendor or supplier"},
          "invoice_number": {"type": "string", "description": "Unique invoice identifier"},
          "total_amount": {"type": "number", "description": "Total amount due"},
          "currency": {"type": "string", "description": "Currency code (e.g. USD, EUR)"},
          "due_date": {"type": "string", "description": "Payment due date", "nullable": true}
        },
        "required": ["vendor_name", "invoice_number", "total_amount", "currency"]
      },
      "extraction_target": "per_doc",
      "tier": "agentic",
      "version": "2.5",
      "cite_sources": true
    }
  }'

用已保存的配置跑抽取

有了已保存的抽取配置之后，只传 configuration_id 就能创建抽取任务 —— 不必再写内联配置。

下载一张样例发票：

终端窗口

mkdir -p invoices
curl -fL -o invoices/invoice_001.pdf https://media.githubusercontent.com/media/run-llama/llama-datasets/main/llama_agents/invoice-contracts/invoice-2-1.pdf

Python
TypeScript
Go
Java
CLI
cURL

import time

# Upload a file
file_obj = client.files.create(file="./invoices/invoice_001.pdf", purpose="extract")

# Extract using the saved configuration — no inline config needed
job = client.extract.create(
    file_input=file_obj.id,
    configuration_id=extract_config.id,
)

# Poll for completion
while job.status not in ("COMPLETED", "FAILED", "CANCELLED"):
    time.sleep(2)
    job = client.extract.get(job.id)

if job.status == "COMPLETED":
    invoice = InvoiceData.model_validate(job.extract_result)
    print(f"Vendor: {invoice.vendor_name}")
    print(f"Total: {invoice.currency} {invoice.total_amount}")

import fs from 'fs';

// Upload a file
const fileObj = await client.files.create({
  file: fs.createReadStream('./invoices/invoice_001.pdf'),
  purpose: 'extract',
});

// Extract using the saved configuration — no inline config needed
let job = await client.extract.create({
  file_input: fileObj.id,
  configuration_id: extractConfig.id,
});

// Poll for completion
while (!['COMPLETED', 'FAILED', 'CANCELLED'].includes(job.status)) {
  await new Promise((r) => setTimeout(r, 2000));
  job = await client.extract.get(job.id);
}

if (job.status === 'COMPLETED') {
  console.log('Extracted:', job.extract_result);
}

// Upload a file
f, err := os.Open("./invoices/invoice_001.pdf")
if err != nil {
    log.Fatal(err)
}
defer f.Close()

fileObj, err := client.Files.New(ctx, llamacloud.FileNewParams{
    File:    f,
    Purpose: "extract",
})
if err != nil {
    log.Fatal(err)
}

// Extract using the saved configuration — no inline config needed
job, err := client.Extract.New(ctx, llamacloud.ExtractNewParams{
    ExtractV2JobCreate: llamacloud.ExtractV2JobCreateParam{
        FileInput:       fileObj.ID,
        ConfigurationID: llamacloud.String(extractConfig.ID),
    },
})
if err != nil {
    log.Fatal(err)
}

// Poll for completion
for job.Status != "COMPLETED" && job.Status != "FAILED" && job.Status != "CANCELLED" {
    time.Sleep(2 * time.Second)
    job, err = client.Extract.Get(ctx, job.ID, llamacloud.ExtractGetParams{})
    if err != nil {
        log.Fatal(err)
    }
}

if job.Status == "COMPLETED" {
    fmt.Println(job.ExtractResult.RawJSON())
}

import ai.llamaindex.llamacloud.models.extract.ExtractCreateParams;
import ai.llamaindex.llamacloud.models.extract.ExtractGetParams;
import ai.llamaindex.llamacloud.models.extract.ExtractV2Job;
import ai.llamaindex.llamacloud.models.extract.ExtractV2JobCreate;
import ai.llamaindex.llamacloud.models.files.FileCreateParams;
import ai.llamaindex.llamacloud.models.files.FileCreateResponse;
import java.nio.file.Paths;

// Upload a file
FileCreateResponse fileObj = client.files().create(
        FileCreateParams.builder()
                .file(Paths.get("./invoices/invoice_001.pdf"))
                .purpose("extract")
                .build());

// Extract using the saved configuration — no inline config needed
ExtractV2Job job = client.extract().create(
        ExtractCreateParams.builder()
                .extractV2JobCreate(
                        ExtractV2JobCreate.builder()
                                .fileInput(fileObj.id())
                                .configurationId(extractConfig.id())
                                .build())
                .build());

// Poll for completion
while (!job.status().equals("COMPLETED")
        && !job.status().equals("FAILED")
        && !job.status().equals("CANCELLED")) {
    Thread.sleep(2000);
    job = client.extract().get(ExtractGetParams.builder().jobId(job.id()).build());
}

if (job.status().equals("COMPLETED")) {
    System.out.println(job.extractResult());
}

终端窗口

# Upload a file
FILE_ID=$(llp files create --file ./invoices/invoice_001.pdf --purpose extract | jq -r '.id')

# Extract using the saved configuration — no inline config needed
JOB_ID=$(llp extract create \
  --file-input "$FILE_ID" \
  --configuration-id "$EXTRACT_CONFIG_ID" \
  | jq -r '.id')

# Poll for completion
while true; do
  JOB=$(llp extract get --job-id "$JOB_ID") || break
  STATUS=$(printf '%s\n' "$JOB" | jq -r '.status')
  case "$STATUS" in COMPLETED|FAILED|CANCELLED) break ;; esac
  sleep 2
done

printf '%s\n' "$JOB" | jq -r 'if .status == "COMPLETED" then .extract_result
  else "Extract job failed: \(.error_message // .)" end'

终端窗口

# Extract using a saved configuration ID
curl -X 'POST' \
  'https://api.cloud.llamaindex.ai/api/v2/extract?project_id={PROJECT_ID}' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $LLAMA_CLOUD_API_KEY" \
  -d '{
    "file_input": "{FILE_ID}",
    "configuration_id": "{EXTRACT_CONFIG_ID}"
  }'

注意

configuration_id 与 configuration 互斥。必须且只能提供其中之一 —— 要么是给已保存配置的 ID，要么是内联的配置对象，不能同时给。

在内联配置里使用 parse_config_id

不必先有已保存的抽取配置，也能用上已保存的解析配置。可以直接在内联的 configuration 块里引用 parse_config_id：

Python
TypeScript
Go
Java
CLI
cURL

# Use a saved parse config with an inline extract config
job = client.extract.create(
    file_input=file_obj.id,
    configuration={
        "parse_config_id": parse_config.id,
        "data_schema": InvoiceData.model_json_schema(),
        "extraction_target": "per_doc",
        "tier": "agentic",
    },
)

// invoiceSchema defined earlier (see Create an Extract Configuration above)
job = await client.extract.create({
  file_input: fileObj.id,
  configuration: {
    parse_config_id: parseConfig.id,
    data_schema: invoiceSchema,
    extraction_target: 'per_doc',
    tier: 'agentic',
  },
});

// Use a saved parse config with an inline extract config
schema := map[string]*llamacloud.ExtractConfigurationDataSchemaUnionParam{
    "type": {OfString: llamacloud.String("object")},
    "properties": {OfAnyMap: map[string]any{
        "vendor_name":  map[string]any{"type": "string", "description": "Name of the vendor"},
        "total_amount": map[string]any{"type": "number", "description": "Total amount due"},
    }},
    "required": {OfAnyArray: []any{"vendor_name", "total_amount"}},
}

job, err = client.Extract.New(ctx, llamacloud.ExtractNewParams{
    ExtractV2JobCreate: llamacloud.ExtractV2JobCreateParam{
        FileInput: fileObj.ID,
        Configuration: llamacloud.ExtractConfigurationParam{
            ParseConfigID:    llamacloud.String(parseConfig.ID),
            DataSchema:       schema,
            ExtractionTarget: llamacloud.ExtractConfigurationExtractionTargetPerDoc,
            Tier:             llamacloud.ExtractConfigurationTierAgentic,
        },
    },
})
if err != nil {
    log.Fatal(err)
}

import ai.llamaindex.llamacloud.models.extract.ExtractConfiguration;

// Use a saved parse config with an inline extract config
ExtractConfiguration.DataSchema schema = ExtractConfiguration.DataSchema.builder()
        .putAdditionalProperty("type", JsonValue.from("object"))
        .putAdditionalProperty("properties", JsonValue.from(Map.of(
                "vendor_name", Map.of("type", "string", "description", "Name of the vendor"),
                "total_amount", Map.of("type", "number", "description", "Total amount due"))))
        .putAdditionalProperty("required", JsonValue.from(List.of("vendor_name", "total_amount")))
        .build();

job = client.extract().create(
        ExtractCreateParams.builder()
                .extractV2JobCreate(
                        ExtractV2JobCreate.builder()
                                .fileInput(fileObj.id())
                                .configuration(
                                        ExtractConfiguration.builder()
                                                .parseConfigId(parseConfig.id())
                                                .dataSchema(schema)
                                                .extractionTarget(ExtractConfiguration.ExtractionTarget.PER_DOC)
                                                .tier(ExtractConfiguration.Tier.AGENTIC)
                                                .build())
                                .build())
                .build());

终端窗口

# Use a saved parse config with an inline extract config
SCHEMA='{"type": "object", "properties": {"vendor_name": {"type": "string", "description": "Name of the vendor"}, "total_amount": {"type": "number", "description": "Total amount due"}}, "required": ["vendor_name", "total_amount"]}'

llp extract create \
  --file-input "$FILE_ID" \
  --configuration "{\"parse_config_id\": \"$PARSE_CONFIG_ID\", \"data_schema\": $SCHEMA, \"extraction_target\": \"per_doc\", \"tier\": \"agentic\"}"

终端窗口

curl -X 'POST' \
  'https://api.cloud.llamaindex.ai/api/v2/extract?project_id={PROJECT_ID}' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $LLAMA_CLOUD_API_KEY" \
  -d '{
    "file_input": "{FILE_ID}",
    "configuration": {
      "parse_config_id": "{PARSE_CONFIG_ID}",
      "data_schema": {
        "type": "object",
        "properties": {
          "vendor_name": {"type": "string", "description": "Name of the vendor"},
          "total_amount": {"type": "number", "description": "Total amount due"}
        },
        "required": ["vendor_name", "total_amount"]
      },
      "extraction_target": "per_doc",
      "tier": "agentic"
    }
  }'

当你希望各任务的解析保持一致、但不同场景要用不同的抽取 schema 时，这种做法很有用。

用已保存的配置做批处理

已保存配置让批量流程更简单 —— 每个文件都传同一个 configuration_id 即可。下载三张样例发票：

终端窗口

mkdir -p invoices
curl -fL -o invoices/invoice_001.pdf https://media.githubusercontent.com/media/run-llama/llama-datasets/main/llama_agents/invoice-contracts/invoice-2-1.pdf
curl -fL -o invoices/invoice_002.pdf https://media.githubusercontent.com/media/run-llama/llama-datasets/main/llama_agents/invoice-contracts/invoice-3-1.pdf
curl -fL -o invoices/invoice_003.pdf https://media.githubusercontent.com/media/run-llama/llama-datasets/main/llama_agents/invoice-contracts/invoice-4-1.pdf

Python
TypeScript
Go
Java
CLI

import os
import asyncio
from pathlib import Path
from llama_cloud import AsyncLlamaCloud

async_client = AsyncLlamaCloud(api_key=os.environ["LLAMA_CLOUD_API_KEY"])
EXTRACT_CONFIG_ID = extract_config.id  # Your saved config ID

async def process_file(file_path: Path) -> dict:
    file_obj = await async_client.files.create(
        file=str(file_path), purpose="extract"
    )

    job = await async_client.extract.create(
        file_input=file_obj.id,
        configuration_id=EXTRACT_CONFIG_ID,
    )

    while job.status not in ("COMPLETED", "FAILED", "CANCELLED"):
        await asyncio.sleep(2)
        job = await async_client.extract.get(job.id)

    if job.status == "COMPLETED":
        return {"file": file_path.name, "data": job.extract_result}
    return {"file": file_path.name, "error": job.error_message}

async def main():
    files = list(Path("./invoices").glob("*.pdf"))
    semaphore = asyncio.Semaphore(10)

    async def bounded(path):
        async with semaphore:
            return await process_file(path)

    results = await asyncio.gather(*[bounded(f) for f in files])

    for r in results:
        if "data" in r:
            print(f"  {r['file']}: {r['data']}")
        else:
            print(f"  {r['file']}: ERROR - {r['error']}")

asyncio.run(main())

import * as path from 'path';

const EXTRACT_CONFIG_ID = extractConfig.id; // Your saved config ID

async function processFile(filePath: string) {
  const fileObj = await client.files.create({
    file: fs.createReadStream(filePath),
    purpose: 'extract',
  });

  let job = await client.extract.create({
    file_input: fileObj.id,
    configuration_id: EXTRACT_CONFIG_ID,
  });

  while (!['COMPLETED', 'FAILED', 'CANCELLED'].includes(job.status)) {
    await new Promise((r) => setTimeout(r, 2000));
    job = await client.extract.get(job.id);
  }

  return {
    file: path.basename(filePath),
    status: job.status,
    data: job.extract_result,
    error: job.error_message,
  };
}

// Process files with bounded concurrency
const filePaths = [
  './invoices/invoice_001.pdf',
  './invoices/invoice_002.pdf',
  './invoices/invoice_003.pdf',
];
const concurrency = 10;

for (let i = 0; i < filePaths.length; i += concurrency) {
  const batch = filePaths.slice(i, i + concurrency);
  const results = await Promise.all(batch.map(processFile));
  results.forEach((r) => console.log(`${r.file}: ${r.status}`));
}

package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "path/filepath"
    "sync"
    "time"

    llamacloud "github.com/run-llama/llama-parse-go"
)

func main() {
    ctx := context.Background()
    client := llamacloud.NewClient()
    sem := make(chan struct{}, 10) // Limit concurrency

    // Look up the latest version of the saved extract configuration by name
    var extractConfigID string
    configs := client.Configurations.ListAutoPaging(ctx, llamacloud.ConfigurationListParams{
        Name:        llamacloud.String("Invoice Extraction"),
        LatestOnly:  llamacloud.Bool(true),
        ProductType: []string{"extract_v2"},
    })
    if configs.Next() {
        extractConfigID = configs.Current().ID
    }
    if err := configs.Err(); err != nil {
        log.Fatal(err)
    }
    if extractConfigID == "" {
        log.Fatal(`no extract configuration named "Invoice Extraction"`)
    }

    type result struct {
        file string
        data llamacloud.ExtractV2JobExtractResultUnion
        err  error
    }

    processFile := func(filePath string) result {
        sem <- struct{}{}
        defer func() { <-sem }()

        name := filepath.Base(filePath)

        f, err := os.Open(filePath)
        if err != nil {
            return result{file: name, err: err}
        }
        defer f.Close()

        fileObj, err := client.Files.New(ctx, llamacloud.FileNewParams{
            File:    f,
            Purpose: "extract",
        })
        if err != nil {
            return result{file: name, err: err}
        }

        job, err := client.Extract.New(ctx, llamacloud.ExtractNewParams{
            ExtractV2JobCreate: llamacloud.ExtractV2JobCreateParam{
                FileInput:       fileObj.ID,
                ConfigurationID: llamacloud.String(extractConfigID),
            },
        })
        if err != nil {
            return result{file: name, err: err}
        }

        for job.Status != "COMPLETED" && job.Status != "FAILED" && job.Status != "CANCELLED" {
            time.Sleep(2 * time.Second)
            job, err = client.Extract.Get(ctx, job.ID, llamacloud.ExtractGetParams{})
            if err != nil {
                return result{file: name, err: err}
            }
        }

        return result{file: name, data: job.ExtractResult}
    }

    filePaths := []string{
        "./invoices/invoice_001.pdf",
        "./invoices/invoice_002.pdf",
        "./invoices/invoice_003.pdf",
    }
    results := make([]result, len(filePaths))

    var wg sync.WaitGroup
    for i, path := range filePaths {
        wg.Add(1)
        go func(i int, path string) {
            defer wg.Done()
            results[i] = processFile(path)
        }(i, path)
    }
    wg.Wait()

    for _, r := range results {
        if r.err != nil {
            fmt.Printf("  %s: ERROR - %v\n", r.file, r.err)
        } else {
            fmt.Printf("  %s: %s\n", r.file, r.data.RawJSON())
        }
    }
}

import ai.llamaindex.llamacloud.models.extract.ExtractCreateParams;
import ai.llamaindex.llamacloud.models.extract.ExtractGetParams;
import ai.llamaindex.llamacloud.models.extract.ExtractV2Job;
import ai.llamaindex.llamacloud.models.extract.ExtractV2JobCreate;
import ai.llamaindex.llamacloud.models.files.FileCreateParams;
import ai.llamaindex.llamacloud.models.files.FileCreateResponse;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

ExecutorService pool = Executors.newFixedThreadPool(10); // Limit concurrency
String extractConfigId = extractConfig.id(); // Your saved config ID

List<String> filePaths = List.of(
        "./invoices/invoice_001.pdf", "./invoices/invoice_002.pdf", "./invoices/invoice_003.pdf");
List<Future<ExtractV2Job>> futures = new ArrayList<>();

for (String filePath : filePaths) {
    futures.add(pool.submit(() -> {
        FileCreateResponse batchFile = client.files().create(
                FileCreateParams.builder()
                        .file(Paths.get(filePath))
                        .purpose("extract")
                        .build());

        ExtractV2Job batchJob = client.extract().create(
                ExtractCreateParams.builder()
                        .extractV2JobCreate(
                                ExtractV2JobCreate.builder()
                                        .fileInput(batchFile.id())
                                        .configurationId(extractConfigId)
                                        .build())
                        .build());

        while (!batchJob.status().equals("COMPLETED")
                && !batchJob.status().equals("FAILED")
                && !batchJob.status().equals("CANCELLED")) {
            Thread.sleep(2000);
            batchJob = client.extract().get(ExtractGetParams.builder().jobId(batchJob.id()).build());
        }

        return batchJob;
    }));
}

for (Future<ExtractV2Job> future : futures) {
    System.out.println(future.get().extractResult());
}
pool.shutdown();

终端窗口

for FILE in ./invoices/*.pdf; do
  FILE_ID=$(llp files create --file "$FILE" --purpose extract | jq -r '.id')

  JOB_ID=$(llp extract create \
    --file-input "$FILE_ID" \
    --configuration-id "$EXTRACT_CONFIG_ID" \
    | jq -r '.id')

  while true; do
    JOB=$(llp extract get --job-id "$JOB_ID") || break
    STATUS=$(printf '%s\n' "$JOB" | jq -r '.status')
    case "$STATUS" in COMPLETED|FAILED|CANCELLED) break ;; esac
    sleep 2
  done

  printf '%s\n' "$JOB" | jq -r --arg file "$(basename "$FILE")" 'if .status == "COMPLETED"
    then "  \($file): \(.extract_result | tojson)"
    else "  \($file): ERROR - \(.error_message // .)" end'
done

列出已保存的配置

你可以按产品类型过滤，列出自己的已保存配置：

Python
TypeScript
Go
Java
CLI
cURL

# List all extract configurations
for cfg in client.configurations.list(product_type=["extract_v2"]):
    print(f"  {cfg.name} ({cfg.id})")

# List all parse configurations
for cfg in client.configurations.list(product_type=["parse_v2"]):
    print(f"  {cfg.name} ({cfg.id})")

// List all extract configurations
for await (const cfg of client.configurations.list({ product_type: ['extract_v2'] })) {
  console.log(`  ${cfg.name} (${cfg.id})`);
}

// List all parse configurations
for await (const cfg of client.configurations.list({ product_type: ['parse_v2'] })) {
  console.log(`  ${cfg.name} (${cfg.id})`);
}

// List all extract configurations
extractConfigs := client.Configurations.ListAutoPaging(ctx, llamacloud.ConfigurationListParams{
    ProductType: []string{"extract_v2"},
})
for extractConfigs.Next() {
    cfg := extractConfigs.Current()
    fmt.Printf("  %s (%s)\n", cfg.Name, cfg.ID)
}
if err := extractConfigs.Err(); err != nil {
    log.Fatal(err)
}

// List all parse configurations
parseConfigs := client.Configurations.ListAutoPaging(ctx, llamacloud.ConfigurationListParams{
    ProductType: []string{"parse_v2"},
})
for parseConfigs.Next() {
    cfg := parseConfigs.Current()
    fmt.Printf("  %s (%s)\n", cfg.Name, cfg.ID)
}
if err := parseConfigs.Err(); err != nil {
    log.Fatal(err)
}

import ai.llamaindex.llamacloud.models.configurations.ConfigurationListParams;

// List all extract configurations
client.configurations().list(
        ConfigurationListParams.builder()
                .addProductType(ConfigurationListParams.ProductType.EXTRACT_V2)
                .build())
        .autoPager()
        .forEach(cfg -> System.out.println("  " + cfg.name() + " (" + cfg.id() + ")"));

// List all parse configurations
client.configurations().list(
        ConfigurationListParams.builder()
                .addProductType(ConfigurationListParams.ProductType.PARSE_V2)
                .build())
        .autoPager()
        .forEach(cfg -> System.out.println("  " + cfg.name() + " (" + cfg.id() + ")"));

终端窗口

# List extract configurations
llp configurations list --product-type extract_v2 | jq -r '"  \(.name) (\(.id))"'

# List parse configurations
llp configurations list --product-type parse_v2 | jq -r '"  \(.name) (\(.id))"'

终端窗口

# List extract configurations
curl -X 'GET' \
  'https://api.cloud.llamaindex.ai/api/v1/beta/configurations?project_id={PROJECT_ID}&product_type=extract_v2' \
  -H 'accept: application/json' \
  -H "Authorization: Bearer $LLAMA_CLOUD_API_KEY"

# List parse configurations
curl -X 'GET' \
  'https://api.cloud.llamaindex.ai/api/v1/beta/configurations?project_id={PROJECT_ID}&product_type=parse_v2' \
  -H 'accept: application/json' \
  -H "Authorization: Bearer $LLAMA_CLOUD_API_KEY"

什么时候该用已保存的配置

场景	做法
快速原型、一次性任务	内联 `configuration` —— 起步最快
许多任务要用同一套设置	已保存的 `configuration_id` —— 定义一次、处处引用
同一套解析、不同抽取 schema	在内联配置里用已保存的 `parse_config_id`
团队共用一条标准流水线	已保存的 `configuration_id` —— 大家都用同一份 config
界面到代码的工作流	在 UI playground 配好 → 保存 → 在 SDK 里用配置 ID

索引

数据加载

查询

存储

成本分析

应用

聊天机器人

问答

结构化数据

智能体

Chat Engines

Query Engine

连接器

文档与节点

摄取流水线

节点解析器

大语言模型

提示词

回调

节点后处理器

响应合成器

检索器

路由

结构化输出

现有数据

Presets and Modes

能力

起步

能力

Examples

Azure Deployment

Databases and Queues

LLM Integrations

概念

通过 API 创建配置

创建解析配置

创建抽取配置

用已保存的配置跑抽取

在内联配置里使用 parse_config_id

用已保存的配置做批处理

列出已保存的配置

什么时候该用已保存的配置

友情链接