afterimage

KO | EN

gitlite — search

#hacktoberfest #react #llm #golang #android #java #awesome #cli #kubernetes #awesome-list #security #ios #mcp #open-source

(★ 42)

Generate conversational, tool-calling, structured-output, and preference datasets — easily and at scale

afterimage 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# AfterImage

**Synthetic conversational dataset generation for LLM fine-tuning.**

Generate multi-turn chat data, DPO preference pairs, and structured outputs —
from a single YAML file or a composable Python API.

[![Tests](https://github.com/altaidevorg/afterimage/actions/workflows/tests.yml/badge.svg)](https://github.com/altaidevorg/afterimage/actions/workflows/tests.yml)
[![Ruff format](https://github.com/altaidevorg/afterimage/actions/workflows/ruff-format.yml/badge.svg)](https://github.com/altaidevorg/afterimage/actions/workflows/ruff-format.yml)
[![Ruff lint](https://github.com/altaidevorg/afterimage/actions/workflows/ruff-lint.yml/badge.svg)](https://github.com/altaidevorg/afterimage/actions/workflows/ruff-lint.yml)
[![PyPI version](https://img.shields.io/pypi/v/afterimage?color=0066cc)](https://pypi.org/project/afterimage)
[![PyPI downloads](https://img.shields.io/pypi/dm/afterimage)](https://pypi.org/project/afterimage)
[![Python](https://img.shields.io/pypi/pyversions/afterimage)](https://pypi.org/project/afterimage)
[![License](https://img.shields.io/badge/license-Apache%202.0-green)](https://raw.githubusercontent.com/altaidevorg/afterimage/main/LICENSE)
[![Docs](https://img.shields.io/badge/docs-afterimage.altai.dev-0066cc)](https://afterimage.altai.dev)
[![Medium](https://img.shields.io/badge/Medium-Blog-12100E?logo=medium&logoColor=white)](https://medium.com/altai-dev/afterimage-is-now-open-source-for-infrastructure-level-dataset-generation-e729507c3b03)

</div>

---

> Demonstration of a typical conversational dataset generation, where Afterimage simulates both sides of the conversation.

![AfterImage demo — Credit Risk Management Q&A Bot](https://raw.githubusercontent.com/altaidevorg/afterimage/main/docs/credit_risk_demo.gif)

> Generating a document-grounded Q&A dataset from BIS credit risk principles → ShareGPT format

---

## News

### July 26, 2026 — Environment-Free Synthetic Agent Traces (`afterimage.agent_trace`)

**afterimage.agent_trace** combines the **ESAT** pipeline (*Environment-free Synthetic Data Generation for API-Calling Agents*, [arXiv:2607.16900](https://arxiv.org/abs/2607.16900)) with a sub-millisecond local **Declarative Tool Simulation Framework** and **Dual-Mode Observation Generation** (`observation_mode: "faker" | "llm"`). It enables training data generation for API-calling AI agents without pre-building backend applications or databases. Key highlights:
- **Dual Observation Modes:** Toggle seamlessly between sub-millisecond local execution (`"faker"`, `< 1 ms`, 0 tokens) and LLM-driven structured observation synthesis (`"llm"`, original ESAT paper methodology).
- **Referential Integrity & Parameter Echoing:** Generator annotations (`param:<name>`, `echo`, `state:account_balance`, `fk:<entity>.<field>`) and explicit Pydantic response models guarantee 100% parameter matching and stateful context mutations.
- **Static AST Verification:** `SchemaVerifier` checks 6 structural invariants with automatic LLM self-correction feedback loops.
- **360-Bucket Grid & Inverse Frequency:** Combinatorial task synthesis grid paired with inverse-frequency endpoint sampling.
- **Trajectory Curation:** Multi-turn ReAct teacher agent interaction (`gemini-3.5-flash-lite`) filtered by a 9-point rubric judge (`gemini-3.6-flash`).

See the [docs](https://afterimage.altai.dev/agent_trace.html) and runnable script [`examples/agent_trace_generator_demo.py`](examples/agent_trace_generator_demo.py).

### May 13, 2026 — Context2skill

**ctx2skill** is a new method to convert and iteratively optimize large contexts to skills that agents can use, originally proposed in [From context to skills: Can language models learn from context skillfully?](https://arxiv.org/html/2604.27660v1). See the [docs](https://afterimage.altai.dev/context_to_skill_tutorial.html) to learn how to use it.

### April 23, 2026 — OpenSimula

**OpenSimula** is an experimental, open implementation of mechanism-design ideas from [**Simula**](https://openreview.net/pdf?id=NALsdGEPhB) (Davidson et al., TMLR; see also Google’s [research blog](https://research.google/blog/designing-synthetic-datasets-for-the-real-world-mechanism-design-and-reasoning-from-first-principles/) on the framing). It covers LLM-built **factor taxonomies**, **weighted mix sampling** over those factors, **meta-prompt** diversification (with optional complexification), **requirement critics** with refinement, and an independent **double-critic** gate for verifiable multiple-choice items. Checkpoints live under an `opensimula/` subtree (manifest, taxonomy bundle, sampling strategy); you can stream datapoints to JSONL, hook **`GenerationMonitor`** into **`OpenSimula`**, or bridge scenarios into **`ConversationGenerator`** via **`SimulaInstructionGeneratorCallback`**.

This module is **not** affiliated with Google and is **not** a reference port of internal systems—it is an independent take on the published Simula recipe.

**Try it:** walkthrough and CLI notes in [`examples/simula/README.md`](examples/simula/README.md), scripts in [`examples/simula/`](examples/simula/), package overview in [`afterimage/simula/README.md`](afterimage/simula/README.md). Narrative + monitoring notes: [OpenSimula](https://afterimage.altai.dev/opensimula.html) · autodoc: [Simula / OpenSimula API](https://afterimage.altai.dev/api/simula.html).

---

## Table of Contents

- [News](#news)
- [Why AfterImage](#why-afterimage)
- [Features](#features)
- [Installation](#installation)
- [Quickstart — CLI](#quickstart--cli)
- [Quickstart — Python API](#quickstart--python-api)
- [Supported LLM Providers](#supported-llm-providers)
- [Export Formats](#export-formats)
- [How It Works](#how-it-works)
- [Configuration Reference](#configuration-reference)
- [Repository Layout](#repository-layout)
- [Contributing](#contributing)
- [License](#license)

---

## Why AfterImage

Fine-tuning a model requires data. Real conversations are slow to collect, expensive to label, and almost never domain-specific enough.

AfterImage flips the problem: **you define what the data should look like**, and it generates it for you using any LLM you already have access to.

```
Your documents  +  LLM  →  Realistic, diverse, quality-filtered training data
```

**What you get:**

- Multi-turn conversations that read like real interactions — not templated Q&A pairs
- Document-grounded datasets tied to your corpus (RAG-style)
- DPO / RLHF preference pairs without a single manual label
- Data already formatted for the training framework you use

---

## Features

| Category | What's included |
|---|---|
| **Generation** | Multi-turn chat · Document-grounded QA · Persona-driven diversity · Structured output · Tool-calling · Environment-free Agent Traces (ESAT + Declarative Engine) |
| **Preference Data** | DPO · RLHF · UltraFeedback · Anthropic HH · ORPO |
| **Quality** | LLM-as-judge · Embedding-based metrics · Auto-improve retries · Composite scoring |
| **Providers** | Gemini · OpenAI · DeepSeek · OpenRouter · Local (vLLM / Ollama / llama.cpp) |
| **Export** | ShareGPT · Alpaca · Messages · LLaMA Factory · Oumi · OpenAI fine-tune · DPO · Raw |
| **Storage** | JSONL (default) · SQLite · PostgreSQL · MySQL |
| **Scale** | Async-first · Concurrent generation · Smart API key rotation with rate limiting |
| **Observability** | Real-time metrics · Configurable alerts · HTML analytics reports |
| **Interface** | CLI · Python API · FastAPI REST server · Gradio demo UI |

---

## Installation

**If you want your agent to do it for you:** Just copy and paste the following to your agent:

```
Read https://afterimage.altai.dev/llms.txt and follow it for installing AfterImage, documentation links, and examples.
```

**If you are doing it yourself:**

```bash
pip install afterimage
# or with uv (recommended)

uv add afterimage
```

**Requires Python 3.11+**

**Optional extras:**

| Extra | What it adds |
|---|---|
| `embeddings-local` | Local embeddings via `sentence-transformers` for Qdrant workflows and embedding-based quality checks |
| `server` | FastAPI REST server (`afterimage-server` CLI entry point) |
| `training` | PyTorch / TRL stack, Gradio UI, and training scripts under `examples/` |

```bash
pip install "afterimage[server]"
pip install "afterimage[embeddings-local,server,training]"
```

---

## Quickstart — CLI

Set your API key and run one command:

```bash
export GEMINI_API_KEY=your_key_here
afterimage generate -c examples/configs/basic.yaml
```

Preview the plan without spending any API credits:

```bash
afterimage generate -c examples/configs/basic.yaml --dry-run
```

**Export to your training framework:**

```bash
# List all available formats
afterimage export --list-formats

# Export to multiple formats in one shot
afterimage export -i output/dataset.jsonl -f sharegpt -f messages -f alpaca

# Create a train/val split automatically
afterimage export -i output/dataset.jsonl -f messages --split 0.9

# Push directly to Hugging Face Hub
afterimage push -c your_config.yaml --repo-id your-org/your-dataset
```

**Generate DPO preference pairs:**

```bash
afterimage preference -c your_config.yaml
```

**Generate environment-free synthetic agent traces:**

```bash
afterimage agent-trace --app-name "banking_app" -n 10 -o "outputs/agent_trajectories.jsonl"
```

**Analyze your dataset:**

```bash
afterimage analyze -i output/dataset.jsonl -o report.html
```

---

## Quickstart — Python API

The CLI is powered by the same composable Python API. Drop into it whenever you need a custom pipeline.

**Minimal conversation generation:**

```python
import asyncio
import os
from afterimage import ConversationGenerator

async def main():
    gen = ConversationGenerator(
        respondent_prompt="You are a helpful AI assistant. Answer clearly and concisely.",
        api_key=os.environ["GEMINI_API_KEY"],
        model_name="gemini-2.5-flash",
    )
    await gen.generate(num_dialogs=50, max_turns=4, max_concurrency=5)
    print(f"Generated {len(gen.load_conversations())} conversations.")

asyncio.run(main())
```

**Environment-free synthetic agent trace generation (`afterimage.agent_trace`):**

```python
import asyncio
import os
from afterimage.agent_trace import AsyncAgentTraceGenerator, ToolActionSpec, ToolParameterSpec

async def main():
    generator = AsyncAgentTraceGenerator(
        api_key=os.environ["GEMINI_API_KEY"],
        architect_model="gemini-3.6-flash",
        teacher_model="gemini-3.5-flash-lite",
        judge_model="gemini-3.6-flash",
    )
    await generator.register_app_domain(
        app_name="banking_app",
        app_description="Customer banking application.",
        actions=[
            ToolActionSpec(
                action_name="get_balance",
                description="Fetch user account balance.",
                parameters=[ToolParameterSpec(name="account_id", type="int")],
                response_model_name="BalanceResponse",
            )
        ],
    )
    trajectories = await generator.generate(num_trajectories=10, max_turns=5)
    print(f"Generated {len(trajectories)} agent trajectories.")

asyncio.run(main())
```

**Document-grounded generation with personas:**

```python
import asyncio
import os
from afterimage import (
    ConversationGenerator,
    PersonaGenerator,
    PersonaInstructionGeneratorCallback,
    InMemoryDocumentProvider,
    WithContextRespondentPromptModifier,
)

DOCUMENTS = [
    "Pour-over coffee is brewed by pouring hot water over grounds through a filter. "
    "Key variables are grind size, water temperature (90–96 °C), and pour rate.",
    "Espresso is brewed at 9 bar pressure through finely-ground beans. "
    "It is the base for lattes, cappuccinos, and macchiatos.",
]

async def main():
    api_key = os.environ["GEMINI_API_KEY"]
    docs = InMemoryDocumentProvider(DOCUMENTS)

# Generate diverse user personas from your documents
    persona_gen = PersonaGenerator(api_key=api_key)
    await persona_gen.generate_from_documents(docs)

gen = ConversationGenerator(
        respondent_prompt="You are a coffee expert. Answer questions based on the provided context.",
        api_key=api_key,
        model_name="gemini-2.5-flash",
        instruction_generator_callback=PersonaInstructionGeneratorCallback(
            api_key=api_key,
            documents=docs,
            num_random_contexts=1,
        ),
        respondent_prompt_modifier=WithContextRespondentPromptModifier(),
    )

await gen.generate(num_dialogs=100, max_turns=3, max_concurrency=5)

asyncio.run(main())
```

**Generate DPO preference pairs:**

```python
import asyncio
import os
from afterimage import ConversationGenerator
from afterimage.preference.generator import PreferenceGenerator
from afterimage.evaluator import ConversationJudge

async def main():
    api_key = os.environ["GEMINI_API_KEY"]

base_gen = ConversationGenerator(
        respondent_prompt="You are a helpful assistant.",
        api_key=api_key,
        model_name="gemini-2.5-flash",
    )

judge = ConversationJudge(api_key=api_key, model_name="gemini-2.5-flash")

pref_gen = PreferenceGenerator(conversation_generator=base_gen, judge=judge)
    await pref_gen.generate(num_pairs=200, max_concurrency=4)

asyncio.run(main())
```

More complete examples live under [`examples/`](examples/). Full API reference is at [afterimage.altai.dev](https://afterimage.altai.dev).

---

## Supported LLM Providers

| Provider | `provider` key | Model examples | Notes |
|---|---|---|---|
| **Google Gemini** | `gemini` | `gemini-2.5-flash`, `gemini-2.0-flash` | Default in CLI configs |
| **OpenAI** | `openai` | `gpt-4o`, `gpt-4o-mini` | Full API support |
| **DeepSeek** | `deepseek` | `deepseek-chat`, `deepseek-reasoner` | Captures chain-of-thought reasoning |
| **OpenRouter** | `openrouter` | Any model via OpenRouter | Access 100+ models with one key |
| **Local** | `local` | Any OpenAI-compatible server | vLLM, Ollama, llama.cpp — zero API cost |

Providers can be mixed freely — use a fast/cheap model to simulate the user (correspondent) and a stronger model to generate answers (respondent).

**Scale beyond rate limits** with `SmartKeyPool` — automatic key rotation across concurrent requests:

```python
from afterimage.key_management import SmartKeyPool
from afterimage import ConversationGenerator

pool = SmartKeyPool(["key_1", "key_2", "key_3"])

gen = ConversationGenerator(
    respondent_prompt="You are a helpful assistant.",
    api_key=pool,
    model_name="gemini-2.5-flash",
)
```

---

## Export Formats

One command converts your raw JSONL to any fine-tuning format:

| Format | `--format` flag | Target framework |
|---|---|---|
| **ShareGPT** | `sharegpt` | LLaMA Factory · FastChat · Axolotl |
| **Alpaca** | `alpaca` | LLaMA Factory · many community trainers |
| **HuggingFace Messages** | `messages` | TRL `SFTTrainer` · HuggingFace ecosystem |
| **LLaMA Factory** | `llama_factory` | LLaMA Factory native format |
| **Oumi** | `oumi` | Oumi training framework |
| **OpenAI Fine-tune** | `openai_finetune` | OpenAI fine-tuning API |
| **DPO** | `dpo` | TRL `DPOTrainer` · preference training |
| **Raw** | `raw` | Custom pipelines — minimal processing |

```bash
# Export and split into train/val in one shot
afterimage export -i output/dataset.jsonl -f sharegpt -f messages --split 0.9
```

---

## How AfterImage Works

AfterImage runs a two-agent loop per dialog:

![AfterImage Dialog-Level Workflow](https://raw.githubusercontent.com/altaidevorg/afterimage/main/docs/workflow-diagram.jpg)

1. **Correspondent** generates user questions — driven by personas, document context, or custom instruction callbacks
2. **Respondent** answers — with optional RAG context injected per turn
3. **Quality gate** scores each dialog using LLM-as-judge + embedding metrics; retries below-threshold dialogs automatically
4. **Storage** writes each dialog incrementally — crash-safe, resumable
5. **Export** converts the raw JSONL to any training format in a single CLI command

---

## Configuration Reference

The fastest path to generation is a YAML config:

```yaml
# examples/configs/basic.yaml

generation:
  num_dialogs: 100
  max_turns: 4
  max_concurrency: 5

model:
  provider: gemini              # gemini | openai | deepseek | openrouter | local
  model_name: gemini-2.5-flash
  api_key_env: GEMINI_API_KEY   # environment variable name

respondent:
  system_prompt: |
    You are an expert assistant. Answer clearly and concisely.

# Optional: document grounding (RAG)
# documents:
#   provider: directory         # directory | file | jsonl | memory | qdrant
#   path: ./my_docs/

# Optional: persona diversity
# personas:
#   enabled: true

# Optional: context-grounded instruction generation
# context:
#   enabled: true
#   num_random_contexts: 2

# Optional: quality gate
# quality:
#   auto_improve: true

output:
  path: ./output/dataset.jsonl
  storage: jsonl                # jsonl | sql
```

```bash
# Validate config before running
afterimage validate -c examples/configs/basic.yaml

# Run
afterimage generate -c examples/configs/basic.yaml
```

All YAML options and their defaults are documented at [afterimage.altai.dev](https://afterimage.altai.dev).

---

## Repository Layout

```
afterimage/              Core library
├── providers/           LLM, document, and embedding providers
├── callbacks/           Instruction generators, stopping criteria, prompt modifiers
├── evaluation/          LLM-as-judge and embedding-based evaluators
├── preference/          DPO / RLHF preference pair generation
├── integrations/        Export format adapters (ShareGPT, Alpaca, Messages, …)
├── analytics/           Dataset analytics engine and HTML report generator
└── server/              FastAPI REST server with SSE progress streaming

examples/
├── configs/             Ready-to-run YAML configs (basic, RAG, local, budget)
├── caselaw_rag/       Qdrant + HF CAP embeddings tutorial (index + generate)
├── demo_ui/             Gradio web UI — interactive generation + fine-tuning
└── *.py                 Python API usage examples

docs/                    Sphinx sources (hosted at afterimage.altai.dev)
tests/                   pytest suite — Python 3.11, 3.12, 3.13
```

---

## Contributing

Contributions are welcome. Read [`DESIGN.md`](DESIGN.md) for architecture notes before opening a large PR.

```bash
# Clone and install all extras
git clone https://github.com/altaidevorg/afterimage
cd afterimage
uv sync --all-extras

# Run the test suite
pytest

# Check style
ruff check .
ruff format .
```

Open an issue before submitting significant changes — it helps align on design direction early and avoids wasted effort.

---

## License

[Apache License 2.0](LICENSE)

---

Built by [Altai Dev](https://altai.dev) · [Documentation](https://afterimage.altai.dev) · [PyPI](https://pypi.org/project/afterimage) · [Blog](https://medium.com/altai-dev/afterimage-is-now-open-source-for-infrastructure-level-dataset-generation-e729507c3b03)

</div>

afterimage

afterimage 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

afterimage

afterimage 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README