데이터셋을 프로그래매틱하게 생성하고 관리하는 방법

examples = [ { "inputs": {"question": "What is the largest mammal?"}, "outputs": {"answer": "The blue whale"}, "metadata": {"source": "Wikipedia"}, }, { "inputs": {"question": "What do mammals and birds have in common?"}, "outputs": {"answer": "They are both warm-blooded"}, "metadata": {"source": "Wikipedia"}, }, { "inputs": {"question": "What are reptiles known for?"}, "outputs": {"answer": "Having scales"}, "metadata": {"source": "Wikipedia"}, }, { "inputs": {"question": "What's the main characteristic of amphibians?"}, "outputs": {"answer": "They live both in water and on land"}, "metadata": {"source": "Wikipedia"}, }, ]

client = Client() dataset_name = "Elementary Animal Questions"

Storing inputs in a dataset lets us

run chains and LLMs over a shared set of examples.

dataset = client.create_dataset( dataset_name=dataset_name, description="Questions and answers about animal phylogenetics.", )

Prepare inputs, outputs, and metadata for bulk creation

client.create_examples( dataset_id=dataset.id, examples=examples )

```typescript TypeScript
import { Client } from "langsmith";

const client = new Client();

const exampleInputs: [string, string][] = [
  ["What is the largest mammal?", "The blue whale"],
  ["What do mammals and birds have in common?", "They are both warm-blooded"],
  ["What are reptiles known for?", "Having scales"],
  [
    "What's the main characteristic of amphibians?",
    "They live both in water and on land",
  ],
];

const datasetName = "Elementary Animal Questions";

// Storing inputs in a dataset lets us
// run chains and LLMs over a shared set of examples.
const dataset = await client.createDataset(datasetName, {
  description: "Questions and answers about animal phylogenetics",
});

// Prepare inputs, outputs, and metadata for bulk creation
const inputs = exampleInputs.map(([inputPrompt]) => ({ question: inputPrompt }));
const outputs = exampleInputs.map(([, outputAnswer]) => ({ answer: outputAnswer }));
const metadata = exampleInputs.map(() => ({ source: "Wikipedia" }));

// Use the bulk createExamples method
await client.createExamples({
  inputs,
  outputs,
  metadata,
  datasetId: dataset.id,
});
```typescript

```java Java
import com.langchain.smith.client.LangsmithClient;
import com.langchain.smith.client.okhttp.LangsmithOkHttpClient;
import com.langchain.smith.core.JsonValue;
import com.langchain.smith.errors.UnexpectedStatusCodeException;
import com.langchain.smith.models.datasets.Dataset;
import com.langchain.smith.models.datasets.DatasetCreateParams;
import com.langchain.smith.models.datasets.DatasetListParams;
import com.langchain.smith.models.examples.bulk.BulkCreateParams;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class CreateDatasetExample {
    public static void main(String[] args) {
        LangsmithClient client = LangsmithOkHttpClient.fromEnv();

        List<String[]> exampleInputs = List.of(
            new String[]{"What is the largest mammal?", "The blue whale"},
            new String[]{"What do mammals and birds have in common?", "They are both warm-blooded"},
            new String[]{"What are reptiles known for?", "Having scales"},
            new String[]{"What's the main characteristic of amphibians?", "They live both in water and on land"}
        );

        String datasetName = "Elementary Animal Questions";

        Dataset dataset;
        try {
            dataset = client.datasets().create(
                DatasetCreateParams.builder()
                    .name(datasetName)
                    .description("Questions and answers about animal phylogenetics")
                    .build()
            );
        } catch (UnexpectedStatusCodeException e) {
            // Dataset already exists, get it
            if (e.statusCode() == 409) {
                DatasetListParams listParams = DatasetListParams.builder()
                    .name(datasetName)
                    .build();
                dataset = client.datasets().list(listParams).items().get(0);
            } else {
                throw e;
            }
        }

        // Prepare inputs, outputs, and metadata for bulk creation
        List<Map<String, String>> inputs = exampleInputs.stream()
            .map(pair -> {
                return Maps.of("question", pair[0]);
            })
            .collect(Collectors.toList());

        List<Map<String, String>> outputs = exampleInputs.stream()
            .map(pair -> {
                return Maps.of("answer", pair[1]);
            })
            .collect(Collectors.toList());

        List<Map<String, String>> metadata = exampleInputs.stream()
            .map(pair -> {
                return Maps.of("source", "Wikipedia");
            })
            .collect(Collectors.toList());

        // Use the bulk createExamples method
        BulkCreateParams.Builder bulkParamsBuilder = BulkCreateParams.builder();
        for (int i = 0; i < inputs.size(); i++) {
            bulkParamsBuilder.addBody(
                BulkCreateParams.Body.builder()
                    .datasetId(dataset.id())
                    .inputs(JsonValue.from(inputs.get(i)))
                    .outputs(JsonValue.from(outputs.get(i)))
                    .metadata(JsonValue.from(metadata.get(i)))
                    .build()
            );
        }

        client.examples().bulk().create(bulkParamsBuilder.build());
    }
}


```java
</CodeGroup>

### 트레이스에서 데이터셋 만들기

트레이스의 런(스팬)에서 데이터셋을 만들려면 같은 접근 방식을 사용할 수 있습니다. 런을 가져오고 필터링하는 **훨씬 많은** 예시는 [트레이스 내보내기](/langsmith/export-traces) 가이드를 참조하세요. 아래에 예시가 있습니다:

<CodeGroup>
```python Python
from langsmith import Client

client = Client()
dataset_name = "Example Dataset"

# Filter runs to add to the dataset
runs = client.list_runs(
  project_name="my_project",
  is_root=True,
  error=False,
)

dataset = client.create_dataset(dataset_name, description="An example dataset")

# Prepare inputs and outputs for bulk creation
examples = [{"inputs": run.inputs, "outputs": run.outputs} for run in runs]

# Use the bulk create_examples method
client.create_examples(
  dataset_id=dataset.id,
  examples=examples
)
```python

```typescript TypeScript
import { Client, Run } from "langsmith";

const client = new Client();
const datasetName = "Example Dataset";

// Filter runs to add to the dataset
const runs: Run[] = [];
for await (const run of client.listRuns({
  projectName: "my_project",
  isRoot: 1,
  error: false,
})) {
  runs.push(run);
}

const dataset = await client.createDataset(datasetName, {
  description: "An example dataset",
  dataType: "kv",
});

// Prepare inputs and outputs for bulk creation
const inputs = runs.map(run => run.inputs);
const outputs = runs.map(run => run.outputs ?? {});

// Use the bulk createExamples method
await client.createExamples({
  inputs,
  outputs,
  datasetId: dataset.id,
});
```typescript

```java Java
import com.langchain.smith.client.LangsmithClient;
import com.langchain.smith.client.okhttp.LangsmithOkHttpClient;
import com.langchain.smith.core.JsonValue;
import com.langchain.smith.models.datasets.Dataset;
import com.langchain.smith.models.datasets.DatasetCreateParams;
import com.langchain.smith.models.examples.bulk.BulkCreateParams;
import com.langchain.smith.models.runs.RunQueryParams;
import com.langchain.smith.models.runs.RunQueryResponse;
import java.util.ArrayList;
import java.util.List;

public class CreateDatasetExample {
    public static void main(String[] args) {
        LangsmithClient client = LangsmithOkHttpClient.fromEnv();
        String projectId = System.getenv("LANGSMITH_PROJECT_ID");
        String datasetName = "Example Dataset";

        List<RunQueryResponse.Run> allRuns = new ArrayList<>();
        String cursor = null;
        try {
            do {
                RunQueryParams.Builder paramsBuilder = RunQueryParams.builder()
                    .addSession(projectId)
                    .isRoot(true)
                    .error(false)
                    .limit(10L);

                if (cursor != null) {
                    paramsBuilder.cursor(cursor);
                }

                RunQueryResponse response = client.runs().query(paramsBuilder.build());
                allRuns.addAll(response.runs());

                // Get cursor for next page
                try {
                    Map<String, JsonValue> cursorProps = response.cursors()._additionalProperties();
                    if (cursorProps != null && cursorProps.containsKey("next")) {
                        JsonValue nextValue = cursorProps.get("next");
                        if (nextValue != null && !nextValue.isNull() && !nextValue.isMissing()) {
                            cursor = nextValue.asString().orElse(null);
                        } else {
                            cursor = null;
                        }
                    } else {
                        cursor = null;
                    }
                } catch (Exception e) {
                    cursor = null;
                }
                if (response.runs().size() < 50) {
                    cursor = null;
                }
            } while (cursor != null && !cursor.isEmpty());
        } catch (Exception e) {
            System.err.println("Error querying runs: " + e.getMessage());
            e.printStackTrace();
            System.exit(1);
        }

        System.out.println("Total runs found: " + allRuns.size());

        // Create dataset
        Dataset dataset = client.datasets().create(
            DatasetCreateParams.builder()
                .name(datasetName)
                .description("An example dataset")
                .build()
        );

        // Prepare inputs and outputs for bulk creation
        BulkCreateParams.Builder bulkParamsBuilder = BulkCreateParams.builder();
        int examplesWithData = 0;
        for (RunQueryResponse.Run run : allRuns) {
            if (run.inputs().isPresent() && run.outputs().isPresent()) {
                // Get the additional properties maps which contain the actual data
                Map<String, JsonValue> inputsMap = run.inputs().get()._additionalProperties();
                Map<String, JsonValue> outputsMap = run.outputs().get()._additionalProperties();

                bulkParamsBuilder.addBody(
                    BulkCreateParams.Body.builder()
                        .datasetId(dataset.id())
                        .inputs(JsonValue.from(inputsMap))
                        .outputs(JsonValue.from(outputsMap))
                        .build()
                );
                examplesWithData++;
            }
        }

        System.out.println("Prepared " + examplesWithData + " examples from " + allRuns.size() + " runs");

        if (examplesWithData == 0) {
            System.err.println("No runs have both inputs and outputs. Cannot create examples.");
            System.exit(1);
        }

        client.examples().bulk().create(bulkParamsBuilder.build());
        System.out.println("Created " + examplesWithData + " examples in dataset");
    }
}
```java
</CodeGroup>

### CSV 파일에서 데이터셋 만들기

이 섹션에서는 CSV 파일을 업로드해 데이터셋을 만드는 방법을 보여드릴게요.

먼저 CSV 파일이 입력 및 출력 키를 나타내는 열로 올바르게 포맷되었는지 확인하세요. 이 키들은 업로드 중에 데이터를 올바르게 매핑하는 데 사용됩니다. 데이터셋에 대해 선택적 이름과 설명을 지정할 수 있습니다. 그렇지 않으면 파일 이름이 데이터셋 이름으로 사용되고 설명은 제공되지 않습니다.

<CodeGroup>
```python Python
from langsmith import Client
import os

client = Client()
csv_file = 'path/to/your/csvfile.csv'
input_keys = ['column1', 'column2'] # replace with your input column names
output_keys = ['output1', 'output2'] # replace with your output column names

dataset = client.upload_csv(
  csv_file=csv_file,
  input_keys=input_keys,
  output_keys=output_keys,
  name="My CSV Dataset",
  description="Dataset created from a CSV file",
  data_type="kv"
)
```python

```typescript TypeScript
import { Client } from "langsmith";

const client = new Client();
const csvFile = 'path/to/your/csvfile.csv';
const inputKeys = ['column1', 'column2']; // replace with your input column names
const outputKeys = ['output1', 'output2']; // replace with your output column names

const dataset = await client.uploadCsv({
  csvFile: csvFile,
  fileName: "My CSV Dataset",
  inputKeys: inputKeys,
  outputKeys: outputKeys,
  description: "Dataset created from a CSV file",
  dataType: "kv"
});
```typescript

```java Java
import com.langchain.smith.client.LangsmithClient;
import com.langchain.smith.client.okhttp.LangsmithOkHttpClient;
import com.langchain.smith.models.datasets.Dataset;
import com.langchain.smith.models.datasets.DatasetUploadParams;
import com.langchain.smith.models.datasets.DataType;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;

LangsmithClient client = LangsmithOkHttpClient.fromEnv();
Path csvFile = Paths.get("path/to/your/csvfile.csv");
List<String> inputKeys = List.of("column1", "column2");
List<String> outputKeys = List.of("output1", "output2");

Dataset dataset = client.datasets().upload(
    DatasetUploadParams.builder()
        .file(csvFile)
        .inputKeys(inputKeys)
        .outputKeys(outputKeys)
        .name("My CSV Dataset")
        .description("Dataset created from a CSV file")
        .dataType(DataType.KV)
        .build()
);
```java
</CodeGroup>

### pandas DataFrame에서 데이터셋 만들기 (Python 전용)

Python 클라이언트는 pandas 데이터프레임에서 데이터셋을 업로드할 수 있는 추가 편의 메서드를 제공합니다.

```python
from langsmith import Client
import os
import pandas as pd

client = Client()
df = pd.read_parquet('path/to/your/myfile.parquet')
input_keys = ['column1', 'column2'] # replace with your input column names
output_keys = ['output1', 'output2'] # replace with your output column names

dataset = client.upload_dataframe(
  df=df,
  input_keys=input_keys,
  output_keys=output_keys,
  name="My Parquet Dataset",
  description="Dataset created from a parquet file",
  data_type="kv" # The default
)

데이터셋 가져오기

Python 및 TypeScript SDK의 list_datasets/listDatasets 메서드를 사용해 LangSmith에서 데이터셋을 프로그래매틱하게 가져올 수 있습니다. 아래는 몇 가지 일반적인 호출입니다.

```typescript TypeScript
import { Client } from "langsmith";

const client = new Client();
```typescript

```java Java
import com.langchain.smith.client.LangsmithClient;
import com.langchain.smith.client.okhttp.LangsmithOkHttpClient;

LangsmithClient client = LangsmithOkHttpClient.fromEnv();
```java
</CodeGroup>

### 모든 데이터셋 조회하기

<CodeGroup>
```python Python
datasets = client.list_datasets()
```python

```typescript TypeScript
const datasets = await client.listDatasets();
```typescript

```java Java
import com.langchain.smith.models.datasets.DatasetListParams;

DatasetListParams listParams = DatasetListParams.builder().build();
var datasets = client.datasets().list(listParams);
```java
</CodeGroup>

### 이름으로 데이터셋 나열하기

정확한 이름으로 검색하려면 다음처럼 할 수 있습니다:

<CodeGroup>
```python Python
datasets = client.list_datasets(dataset_name="My Test Dataset 1")
```python

```typescript TypeScript
const datasets = await client.listDatasets({
  datasetName: "My Test Dataset 1"
});
```typescript

```java Java
import com.langchain.smith.models.datasets.DatasetListParams;

DatasetListParams listParams = DatasetListParams.builder()
    .name("My Test Dataset 1")
    .build();
var datasets = client.datasets().list(listParams);
```java
</CodeGroup>

대소문자를 구분하지 않는 부분 문자열 검색을 원한다면 다음을 시도해 보세요:

<CodeGroup>
```python Python
datasets = client.list_datasets(dataset_name_contains="some substring")
```python

```typescript TypeScript
const datasets = await client.listDatasets({
  datasetNameContains: "some substring"
});
```typescript

```java Java
import com.langchain.smith.models.datasets.DatasetListParams;

DatasetListParams listParams = DatasetListParams.builder()
    .nameContains("some substring")
    .build();
var datasets = client.datasets().list(listParams);
```java
</CodeGroup>

### 유형별로 데이터셋 나열하기

유형으로 데이터셋을 필터링할 수 있습니다:

<CodeGroup>
```python Python
datasets = client.list_datasets(data_type="kv")
```python

```typescript TypeScript
const datasets = await client.listDatasets({
  dataType: "kv"
});
```typescript

```java Java
import com.langchain.smith.models.datasets.DatasetListParams;

DatasetListParams listParams = DatasetListParams.builder()
    .datatype(DataType.of("kv"))
    .build();
var datasets = client.datasets().list(listParams);
```java
</CodeGroup>

## 예제 가져오기

Python 및 TypeScript SDK의 `list_examples`/`listExamples` 메서드를 사용해 LangSmith에서 예제를 프로그래매틱하게 가져올 수 있습니다. 아래는 몇 가지 일반적인 호출입니다.

<Info>
아래 코드 스니펫을 실행하기 전에 클라이언트를 초기화하세요.
</Info>

<CodeGroup>
```python Python
from langsmith import Client

client = Client()
```python

```typescript TypeScript
import { Client } from "langsmith";

const client = new Client();
```typescript

```java Java
import com.langchain.smith.client.LangsmithClient;
import com.langchain.smith.client.okhttp.LangsmithOkHttpClient;

LangsmithClient client = LangsmithOkHttpClient.fromEnv();
```java
</CodeGroup>

### 데이터셋의 모든 예제 나열하기

데이터셋 ID로 필터링할 수 있습니다:

<CodeGroup>
```python Python
examples = client.list_examples(dataset_id="c9ace0d8-a82c-4b6c-13d2-83401d68e9ab")
```python

```typescript TypeScript
const examples = await client.listExamples({
  datasetId: "c9ace0d8-a82c-4b6c-13d2-83401d68e9ab"
});
```typescript

```java Java
import com.langchain.smith.models.examples.ExampleListParams;

ExampleListParams listParams = ExampleListParams.builder()
    .dataset("c9ace0d8-a82c-4b6c-13d2-83401d68e9ab")
    .build();
var examples = client.examples().list(listParams);
```java
</CodeGroup>

또는 데이터셋 이름으로 필터링할 수 있습니다(조회하려는 데이터셋 이름과 정확히 일치해야 합니다):

<CodeGroup>
```python Python
examples = client.list_examples(dataset_name="My Test Dataset")
```python

```typescript TypeScript
const examples = await client.listExamples({
  datasetName: "My test Dataset"
});
```typescript
</CodeGroup>

### ID로 예제 나열하기

ID로 여러 예제를 나열할 수도 있습니다.

<CodeGroup>
```python Python
example_ids = [
  '734fc6a0-c187-4266-9721-90b7a025751a',
  'd6b4c1b9-6160-4d63-9b61-b034c585074f',
  '4d31df4e-f9c3-4a6e-8b6c-65701c2fed13',
]

examples = client.list_examples(example_ids=example_ids)
```python

```typescript TypeScript
const exampleIds = [
  "734fc6a0-c187-4266-9721-90b7a025751a",
  "d6b4c1b9-6160-4d63-9b61-b034c585074f",
  "4d31df4e-f9c3-4a6e-8b6c-65701c2fed13",
];

const examples = await client.listExamples({
  exampleIds: exampleIds
});
```typescript

```java Java
import com.langchain.smith.models.examples.ExampleListParams;
import java.util.List;

List<String> exampleIds = List.of(
    "734fc6a0-c187-4266-9721-90b7a025751a",
    "d6b4c1b9-6160-4d63-9b61-b034c585074f",
    "4d31df4e-f9c3-4a6e-8b6c-65701c2fed13"
);

ExampleListParams listParams = ExampleListParams.builder()
    .id(exampleIds)
    .build();
var examples = client.examples().list(listParams);
```java
</CodeGroup>

### 메타데이터로 예제 나열하기

메타데이터로 예제를 필터링할 수도 있습니다. 아래는 특정 메타데이터 키-값 쌍을 가진 예제를 조회하는 예시입니다. 내부적으로 예제의 메타데이터가 지정한 키-값 쌍을 포함하는지 확인합니다.

예를 들어 메타데이터가 `{"foo": "bar", "baz": "qux"}`인 예제가 있다면 `{foo: bar}`와 `{baz: qux}` 둘 다 일치하며 `{foo: bar, baz: qux}`도 일치합니다.

<CodeGroup>
```python Python
examples = client.list_examples(dataset_name=dataset_name, metadata={"foo": "bar"})
```python

```typescript TypeScript
const examples = await client.listExamples({
  datasetName: datasetName,
  metadata: {foo: "bar"}
});
```typescript

```java Java
import com.langchain.smith.models.examples.ExampleListParams;

ExampleListParams listParams = ExampleListParams.builder()
    .datasetId(datasetId)
    .metadata("{\"foo\":\"bar\"}")
    .build();
var examples = client.examples().list(listParams);
```java
</CodeGroup>

### 구조화된 필터로 예제 나열하기

구조화된 필터 쿼리 언어를 사용해 [런을 가져오는 것](/langsmith/export-traces#use-filter-query-language)과 유사하게 예제를 가져올 수 있습니다.

<Note>
이 기능은 현재 Python SDK v0.1.83 이상과 TypeScript SDK v0.1.35 이상에서만 사용할 수 있습니다.

또한 구조화된 필터 쿼리 언어는 `metadata` 필드에 대해서만 지원됩니다.
</Note>

`has` 연산자를 사용해 특정 키/값 쌍을 포함한 메타데이터 필드를 가진 예제를 가져오고, `exists` 연산자를 사용해 특정 키를 포함한 메타데이터 필드를 가진 예제를 가져올 수 있습니다. 또한 `and` 연산자를 사용해 여러 필터를 연결하고 `not` 연산자를 사용해 필터를 부정할 수 있습니다.

<CodeGroup>
```python Python
examples = client.list_examples(
  dataset_name=dataset_name,
  filter='and(not(has(metadata, \'{"foo": "bar"}\')), exists(metadata, "tenant_id"))'
)
```python

```typescript TypeScript
const examples = await client.listExamples({
  datasetName: datasetName,
  filter: 'and(not(has(metadata, \'{"foo": "bar"}\')), exists(metadata, "tenant_id"))'
});
```typescript

```java Java
import com.langchain.smith.models.examples.ExampleListParams;

String filter = "and(not(has(metadata, '{\"foo\": \"bar\"}')), exists(metadata, \"tenant_id\"))";

ExampleListParams listParams = ExampleListParams.builder()
    .datasetId(datasetId)
    .filter(filter)
    .build();
var examples = client.examples().list(listParams);
```java
</CodeGroup>

## 예제 업데이트하기

### 단일 예제 업데이트

Python 및 TypeScript SDK의 `update_example`/`updateExample` 메서드를 사용해 LangSmith에서 예제를 프로그래매틱하게 업데이트할 수 있습니다. 아래에 예시가 있습니다.

<CodeGroup>
```python Python
client.update_example(
  example_id=example.id,
  inputs={"input": "updated input"},
  outputs={"output": "updated output"},
  metadata={"foo": "bar"},
  split="train"
)
```python

```typescript TypeScript
await client.updateExample(example.id, {
  inputs: { input: "updated input" },
  outputs: { output: "updated output" },
  metadata: { "foo": "bar" },
  split: "train",
});
```typescript

```java Java
import com.langchain.smith.core.JsonValue;
import com.langchain.smith.models.examples.ExampleUpdateParams;

 // Create Inputs using the builder
ExampleUpdateParams.Inputs inputsObj = ExampleUpdateParams.Inputs.builder()
    .putAdditionalProperty("input", JsonValue.from("updated input"))
    .build();

// Create Outputs using the builder
ExampleUpdateParams.Outputs outputsObj = ExampleUpdateParams.Outputs.builder()
    .putAdditionalProperty("output", JsonValue.from("updated output"))
    .build();

// Create Metadata using the builder
ExampleUpdateParams.Metadata metadataObj = ExampleUpdateParams.Metadata.builder()
    .putAdditionalProperty("foo", JsonValue.from("bar"))
    .build();

ExampleUpdateParams updateParams = ExampleUpdateParams.builder()
    .inputs(inputsObj)
    .outputs(outputsObj)
    .metadata(metadataObj)
    .split("train")
    .build();

ExampleUpdateResponse updateResponse = client.examples().update(example.id(), updateParams);
```java
</CodeGroup>

### 예제 일괄 업데이트

Python 및 TypeScript SDK의 `update_examples`/`updateExamples` 메서드를 사용해 단일 요청에서 여러 예제를 프로그래매틱하게 업데이트할 수도 있습니다. 아래에 예시가 있습니다.

<CodeGroup>
```python Python
client.update_examples(
  example_ids=[example.id, example_2.id],
  inputs=[{"input": "updated input 1"}, {"input": "updated input 2"}],
  outputs=[
      {"output": "updated output 1"},
      {"output": "updated output 2"},
  ],
  metadata=[{"foo": "baz"}, {"foo": "qux"}],
  splits=[["training", "foo"], "training"] # Splits can be arrays or standalone strings
)
```python

```typescript TypeScript
await client.updateExamples([
  {
    id: example.id,
    inputs: { input: "updated input 1" },
    outputs: { output: "updated output 1" },
    metadata: { foo: "baz" },
    split: ["training", "foo"] // Splits can be arrays or standalone strings
  },
  {
    id: example2.id,
    inputs: { input: "updated input 2" },
    outputs: { output: "updated output 2" },
    metadata: { foo: "qux" },
    split: "training"
  },
]);
```typescript

```java Java
Map<String, String> inputs1 = Map.of("question", "What is the capital of France?")
Map<String, String> outputs1 = Map.of("answer", "The capital of France is Paris.");
Map<String, String> metadata1 = Map.of(
    "source", "Wikipedia",
    "difficulty", "easy"
);

Map<String, String> inputs2 = Map.of("question", "What is 2 + 2?");
Map<String, String> outputs2 = Map.of("answer", "The answer is 4.");
Map<String, String> metadata2 = Map.of(
    "source", "Math textbook",
    "difficulty", "easy");

BulkPatchAllParams.Builder bulkParamsBuilder = BulkPatchAllParams.builder();

bulkParamsBuilder.addBody(
    BulkPatchAllParams.Body.builder()
        .id(example1.id())
        .inputs(buildInputs(inputs1))
        .outputs(buildOutputs(outputs1))
        .metadata(buildMetadata(metadata1))
        .splitOfStrings(Arrays.asList("training", "validation"))
        .build()
);

bulkParamsBuilder.addBody(
    BulkPatchAllParams.Body.builder()
        .id(example2.id())
        .inputs(buildInputs(inputs2))
        .outputs(buildOutputs(outputs2))
        .metadata(buildMetadata(metadata2))
        .split("test")
        .build()
);

client.examples().bulk().patchAll(bulkParamsBuilder.build());
```java
</CodeGroup>

***

> 출처: [문서](https://docs.langchain.com/langsmith/manage-datasets-programmatically)

## 더 알아보기 (Learn more)

- [Connect these docs](/use-these-docs) to Claude, VSCode, and more via MCP for real-time answers.
- [Edit this page on GitHub](https://github.com/langchain-ai/docs/edit/main/src/langsmith/manage-datasets-programmatically.mdx) or [file an issue](https://github.com/langchain-ai/docs/issues/new/choose).