Arbor Framework

Arbor provides the ArborGRPO compiler to optimize DSPy programs using Reinforcement Learning (specifically Group Relative Policy Optimization).

To use it, you must:

1. Initialize the Arbor server using arbor.init().
2. Define a DSPy program.
3. Connect the program to Arbor using ArborProvider and a dspy.LM configured with the openai/arbor:{model_name} prefix and the base_url provided by arbor.init().
4. Define a reward function that takes (example, pred, trace=None) and returns a float.
5. Configure ArborGRPO with your metric, training arguments (train_kwargs), and rollout settings.
6. Call compiler.compile(student, trainset, valset) to run the optimization.

import dspy
import arbor
from arbor import ArborGRPO, ArborProvider

# 1. Start Arbor server
arbor_server_info = arbor.init()

# 2. Define DSPy program
translate_program = dspy.Predict("english -> french")

# 3. Connect DSPy to Arbor
provider = ArborProvider()
model_name = "Qwen/Qwen2.5-1.5B-Instruct"
هاlm = dspy.LM(
    model=f"openai/arbor:{model_name}",
    provider=provider,
    api_base=arbor_server_info["base_url"],
    api_key="arbor",
    temperature=1.0,
    top_p=1.0,
    top_k=-1,
    repetition_penalty=1.0,
    max_tokens=2048,
)
translate_program.set_lm(lm)

# 4. Define reward function
def my_reward(example, pred, trace=None) -> float:
    return float(len(set(pred.french)))

# 5. Configure compiler
compiler = ArborGRPO(
    metric=my_reward,
    num_dspy_examples_per_grpo_step=6,
    num_rollouts_per_grpo_step=24,
    train_kwargs={"learning_rate": 1e-6, "num_training_gpus": 3},
    # ... other args
)

# 6. Run optimization
optimized_translate = compiler.compile(
    student=translate_program,
    trainset=trainset,
    valset=valset,
)

To train Claude Code on your specific documentation standards, create a CLAUDE.md file at the root of your repository. This file acts as a set of instructions for the agent regarding project context, content strategy, writing standards, and workflows.

Below is an example configuration tailored for a Mintlify documentation project.

# Mintlify documentation

## Working relationship
- You can push back on ideas-this can lead to better documentation. Cite sources and explain your reasoning when you do so
- ALWAYS ask for clarification rather than making assumptions
- NEVER lie, guess, or make up information

## Project context
- Format: MDX files with YAML frontmatter
- Config: docs.json for navigation, theme, settings
- Components: Mintlify components

## Content strategy
- Document just enough for user success - not too much, not too little
- Prioritize accuracy and usability of information
- Make content evergreen when possible
- Search for existing information before adding new content. Avoid duplication unless it is done for a strategic reason
- Check existing patterns for consistency
- Start by making the smallest reasonable changes

## Frontmatter requirements for pages
- title: Clear, descriptive page title
- description: Concise summary for SEO/navigation

## Writing standards
- Second-person voice ("you")
- Prerequisites at start of procedural content
- Test all code examples before publishing
- Match style and formatting of existing pages
- Include both basic and advanced use cases
- Language tags on all code blocks
- Alt text on all images
- Relative paths for internal links

## Git workflow
- NEVER use --no-verify when committing
- Ask how to handle uncommitted changes before starting
- Create a new branch when no clear branch exists for changes
- Commit frequently throughout development
- NEVER skip or disable pre-commit hooks

## Do not
- Skip frontmatter on any MDX file
- Use absolute URLs for internal links
- Include untested code examples
- Make assumptions - always ask for clarification