---
license: cc-by-nc-sa-4.0
language:
- en
pretty_name: Tool-Calling Dataset for Drug Discovery (TCDD)
task_categories:
- text-generation
tags:
- tool-calling
- function-calling
- drug-discovery
- chemistry
- agents
- sharegpt
size_categories:
- 1K<n<10K
configs:
- config_name: default
  default: true
  data_files:
  - split: train
    path: tool_calling_memory_pool.json
---

# TCDD: Tool-Calling Dataset for Drug Discovery

TCDD is the domain-specific tool-calling dataset introduced with **DrugPilot**, an LLM-based parameterized reasoning agent for drug discovery. It contains ShareGPT-style traces in which an assistant interprets a drug-discovery request, selects a tool, supplies its arguments, observes the tool output, and produces a final response. Some traces also demonstrate multi-turn use of the Parameterized Memory Pool (PMP).

The dataset is intended to support supervised fine-tuning and evaluation of three capabilities:

1. selecting an appropriate drug-discovery tool from a natural-language request;
2. extracting domain-specific parameters such as SMILES, protein sequences, cell lines, and property names; and
3. reading from and writing results to DrugPilot's Parameterized Memory Pool.

- **Paper:** [DrugPilot: LLM-based Parameterized Reasoning Agent for Drug Discovery](https://arxiv.org/abs/2505.13940)
- **Code:** [wzn99/DrugPilot](https://github.com/wzn99/DrugPilot)
- **Data file:** [`tool_calling_memory_pool.json`](https://huggingface.co/datasets/lik98/TCDD/blob/main/tool_calling_memory_pool.json)

## Dataset Viewer and repository statistics

The YAML configuration above explicitly exposes the complete JSON file in the Hugging Face Dataset Viewer as the `default` configuration and `train` split. The Viewer is paginated; all records remain available through the page controls or the `datasets` library.

Statistics below were computed from the file currently published in this repository:

| Item | Value |
|---|---:|
| Records | 3,098 |
| Conversation messages | 17,402 |
| File size | 11,643,767 bytes |
| Columns | `conversations`, `system`, `tools` |
| Conversation length | 4–8 messages |
| Four-message records | 1,843 |
| Six-message records | 5 |
| Eight-message records | 1,250 |

The DrugPilot paper describes the benchmark as **2,800 annotated samples**, including 2,500 training samples and 300 testing samples. The single artifact currently hosted here contains 3,098 records and does not encode the paper's original train/test membership. For that reason, Hugging Face exposes the full file as one `train` split; users reproducing the paper should obtain or reconstruct the intended split before comparing benchmark results.

## Dataset structure

Each top-level item has three fields:

| Field | Type | Description |
|---|---|---|
| `conversations` | list of objects | Ordered dialogue messages. Every message has string fields `from` and `value`. |
| `system` | string | System instruction that defines the expected tool-calling behavior and output format. |
| `tools` | string | A JSON-serialized list of available tool definitions, including names, descriptions, parameters, and required fields. |

The `from` field uses these role labels:

- `human`: the user's natural-language request;
- `function_call`: the selected function and arguments, represented as a JSON-like string;
- `observation`: the tool result and a snapshot of the PMP keys;
- `gpt`: the assistant's natural-language answer.

An abbreviated record looks like this:

```json
{
  "conversations": [
    {
      "from": "human",
      "value": "Determine the thermodynamic free energy ... MemoryPool(arguments=dict_keys([]))"
    },
    {
      "from": "function_call",
      "value": "{\"name\": \"drug_property_prediction\", \"arguments\": {...}}"
    },
    {
      "from": "observation",
      "value": "{\"task\": ..., \"result\": ...} MemoryPool(arguments=dict_keys([...]))"
    },
    {
      "from": "gpt",
      "value": "The free energy of dissolution ..."
    }
  ],
  "system": "You are a function calling AI model ...",
  "tools": "[{\"name\": \"drug_property_prediction\", ...}]"
}
```

### Tool labels in the published artifact

The paper organizes TCDD around eight representative drug-discovery task families. The current JSON contains the following nine distinct callable labels. Counts refer to function-call messages, not top-level records; multi-turn records can contain more than one call.

| Function label | Calls |
|---|---:|
| `drug_property_prediction` | 841 |
| `drug_target_affinity_regression_predict` | 689 |
| `drug_cell_response_regression_predict` | 621 |
| `drug_target_classification_predict` | 503 |
| `drug_cell_response_regression_optimization` | 490 |
| `drug_cell_response_regression_generation` | 449 |
| `Retrosynthetic_reaction_pathway_prediction` | 430 |
| `drug_drug_response_predict` | 290 |
| `drug_target_affinity_classification_predict` | 40 |

## Data creation

According to the paper, TCDD simulates realistic user–assistant interactions across single-turn dialogue, multi-turn workflows, parameter-error correction, and memory-pool updates. The authors varied user-query wording and molecular inputs, and included complete instructions as well as cases with missing or misspelled parameters. The paper describes approximately 50% single-turn samples, 30% multi-turn samples, and 20% parameter-error scenarios in the original benchmark design.

The task content draws on drug-discovery resources listed in the paper, including BACE, BBBP, ESOL, FreeSolv, LIPO, GDSCv2, DAVIS, KIBA, BindingDB, DrugBank, TWOSIDES, ZINC, QM9, and USPTO. See the paper and the source datasets for collection details and original terms.

## Loading the data

Install the Hugging Face `datasets` library and load the repository directly:

```python
from datasets import load_dataset

dataset = load_dataset("lik98/TCDD")
train = dataset["train"]

print(train)
print(train[0]["conversations"])
```

To parse the serialized tool schema for a record:

```python
import json

tool_schema = json.loads(train[0]["tools"])
print(tool_schema[0]["name"])
```

The original file can also be downloaded without converting it:

```python
from huggingface_hub import hf_hub_download

path = hf_hub_download(
    repo_id="lik98/TCDD",
    filename="tool_calling_memory_pool.json",
    repo_type="dataset",
)
```

## Intended uses

TCDD may be useful for:

- supervised fine-tuning of tool- or function-calling language models;
- evaluating tool selection, argument extraction, and multi-turn tool use;
- studying structured memory for scientific agents; and
- prototyping drug-discovery assistants that connect language models to specialist tools.

When using TCDD as a benchmark, define and publish the exact split, preprocessing rules, prompt template, and parsing policy used in the experiment.

## Limitations and responsible use

- The data is intended for research and engineering, not clinical diagnosis, treatment selection, laboratory safety decisions, or unsupervised real-world drug development.
- Tool observations and assistant responses should not be assumed to be experimentally validated. Molecular strings, protein sequences, numerical outputs, and generated text should be checked with appropriate domain tools and expert review.
- `tools` is a serialized JSON string rather than a nested column. Most `function_call` values are also JSON strings, but some contain unescaped backslashes in SMILES notation and are not valid strict JSON. Use a validation or normalization step before calling `json.loads` on every function-call value.
- The published artifact has no explicit train/validation/test field and its row count differs from the benchmark size reported in the paper. Avoid accidental train–test leakage when creating a new split.
- Source databases may have their own licenses, access conditions, biases, and coverage limitations. Users should review those terms for their intended use.
- Drug-discovery datasets can overrepresent well-studied molecules, targets, cell lines, and assay conditions. Performance on these traces does not establish generalization to novel chemistry or experimental settings.

## License

This repository is released under the [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International license](https://creativecommons.org/licenses/by-nc-sa/4.0/) (`CC BY-NC-SA 4.0`). Users are responsible for confirming that their use also complies with the terms of the underlying source datasets.

## Citation

If you use TCDD or DrugPilot, please cite:

```bibtex
@article{li2025drugpilot,
  title   = {DrugPilot: LLM-based Parameterized Reasoning Agent for Drug Discovery},
  author  = {Li, Kun and Wu, Zhennan and Wang, Shoupeng and Wu, Jia and Pan, Shirui and Hu, Wenbin},
  journal = {arXiv preprint arXiv:2505.13940},
  year    = {2025},
  doi     = {10.48550/arXiv.2505.13940},
  url     = {https://arxiv.org/abs/2505.13940}
}
```

## Related resources

- DrugPilot repository: <https://github.com/wzn99/DrugPilot>
- Paper: <https://arxiv.org/abs/2505.13940>
- Dataset repository: <https://huggingface.co/datasets/lik98/TCDD>