# Technical Distinction Between Legacy Davinci and text-davinci-003 in the OpenAI API

> Understand the technical difference between legacy Davinci and text-davinci-003 on the OpenAI API. Discover how instruction tuning and RLHF improve prompt accuracy in the newer model.

- Repository: [OpenAI/openai-python](https://github.com/openai/openai-python)
- Tags: deep-dive
- Published: 2026-02-16

---

**The technical distinction between legacy `davinci` models and `text-davinci-003` is server-side only—while both use the same Completions API endpoint in the `openai-python` SDK, the newer model utilizes instruction tuning and RLHF optimization to follow prompts more accurately, whereas legacy Davinci functions as a pure completion engine without explicit instruction-following behavior.**

The `openai/openai-python` repository provides a thin HTTP wrapper that delegates all model-specific logic to OpenAI's servers. When working with the OpenAI API, understanding the technical distinction between davinci and text-davinci-003 helps developers optimize prompt engineering and parameter selection despite the SDK treating both as opaque string identifiers.

## How the OpenAI Python SDK Handles Model Selection

The SDK contains no model implementations; it merely forwards your request to OpenAI's infrastructure. In [`src/openai/_client.py`](https://github.com/openai/openai-python/blob/main/src/openai/_client.py), the `OpenAI` class initializes a generic client that passes the `model` parameter as a string literal to the API. Whether you specify `"davinci"` or `"text-davinci-003"`, the client code in [`src/openai/resources/completions.py`](https://github.com/openai/openai-python/blob/main/src/openai/resources/completions.py) constructs an identical HTTP payload structure. The server internally routes to different inference clusters based on the model name, meaning the technical distinction between davinci and text-davinci-003 resides entirely in OpenAI's backend training data, fine-tuning methodology, and inference optimization—not in the SDK source code.

## Core Technical Differences

### Training Objective and Instruction Following

**Legacy Davinci** engines (including `davinci` and `davinci-002`) operate as pure autoregressive language models trained on broad internet text to maximize next-token prediction accuracy. They lack explicit instruction-following training. **text-davinci-003**, built on the same base GPT-3 architecture, incorporates instruction tuning and Reinforcement Learning from Human Feedback (RLHF). This optimization enables the newer model to interpret natural-language directives within prompts and generate responses aligned with user intent rather than merely completing the statistical likelihood of the text sequence.

### API Endpoint Compatibility

Both model families access the **Completions** API through the identical interface defined in [`src/openai/resources/completions.py`](https://github.com/openai/openai-python/blob/main/src/openai/resources/completions.py). The `client.completions.create()` method accepts either model identifier without validation or branching logic in the SDK. According to the API reference in [`api.md`](https://github.com/openai/openai-python/blob/main/api.md), both legacy and newer model names populate the same completions table, confirming endpoint parity. The request building pattern mirrors that of chat completions in [`src/openai/resources/chat/completions/completions.py`](https://github.com/openai/openai-python/blob/main/src/openai/resources/chat/completions/completions.py), though `text-davinci-003` predates the chat-based architecture.

### Parameter Support and Behavior

While the SDK forwards identical parameter schemas for both models, the server-side behavior differs significantly. Legacy Davinci ignores instruction-specific context and performs best with explicit few-shot prompting in the `prompt` string. **text-davinci-003** respects standard completion parameters—`max_tokens`, `temperature`, `top_p`, `stop`—but demonstrates superior performance with lower `temperature` values (0.0-0.3) due to its deterministic instruction-following optimization. The newer model also handles implicit constraints within prompts more reliably, reducing the need for elaborate prompt engineering required by its predecessor.

### Performance and Cost Characteristics

Legacy Davinci models generally incur higher latency and cost per token because they utilize larger, less optimized inference pipelines focused on raw completion generation. **text-davinci-003** offers improved inference speed and cost efficiency through optimized serving infrastructure tailored for instruction-tuned models. For equivalent token budgets, `text-davinci-003` typically yields higher-quality outputs requiring fewer completion tokens to satisfy the same user instruction.

## Code Examples: Switching Between Models

The [`README.md`](https://github.com/openai/openai-python/blob/main/README.md) demonstrates basic usage patterns applicable to both generations. Here are practical implementations showing how the SDK treats model selection as a string configuration:

### Legacy Davinci Completion

```python
from openai import OpenAI

client = OpenAI()

response = client.completions.create(
    model="davinci",               # legacy model identifier

    prompt="Write a short poem about winter.",
    max_tokens=50,
    temperature=0.9,
)

print(response.choices[0].text)

```

### text-davinci-003 Completion

```python
from openai import OpenAI

client = OpenAI()

response = client.completions.create(
    model="text-davinci-003",      # instruction-tuned model

    prompt="Write a short poem about winter.",
    max_tokens=50,
    temperature=0.5,               # lower temperature leverages instruction tuning

)

print(response.choices[0].text)

```

### Dynamic Model Selection

```python
def generate(prompt: str, use_modern: bool = True):
    model = "text-davinci-003" if use_modern else "davinci"
    client = OpenAI()
    return client.completions.create(
        model=model,
        prompt=prompt,
        max_tokens=100,
        temperature=0.7,
    ).choices[0].text

# Legacy generation

print(generate("Explain Newton's first law.", use_modern=False))

# Modern instruction-tuned generation  

print(generate("Explain Newton's first law.", use_modern=True))

```

## Summary

- The `openai-python` SDK treats both legacy `davinci` and `text-davinci-003` as opaque string identifiers, routing requests through [`src/openai/resources/completions.py`](https://github.com/openai/openai-python/blob/main/src/openai/resources/completions.py) without client-side model logic.
- **Legacy Davinci** functions as a pure completion model trained for next-token prediction, requiring explicit prompt engineering and higher temperature values.
- **text-davinci-003** incorporates instruction tuning and RLHF, enabling better prompt interpretation, lower effective temperature requirements, and superior cost-efficiency.
- Both models utilize identical API endpoints and SDK methods, with distinctions manifesting solely in server-side inference behavior documented in [`api.md`](https://github.com/openai/openai-python/blob/main/api.md).

## Frequently Asked Questions

### Can I use the Chat Completions API with text-davinci-003?

No. The `text-davinci-003` model exclusively supports the Legacy Completions API endpoint defined in [`src/openai/resources/completions.py`](https://github.com/openai/openai-python/blob/main/src/openai/resources/completions.py). The Chat Completions API, implemented in [`src/openai/resources/chat/completions/completions.py`](https://github.com/openai/openai-python/blob/main/src/openai/resources/chat/completions/completions.py), requires chat-specific models like `gpt-3.5-turbo` or `gpt-4` that understand the messages array format with system and user roles.

### Does the OpenAI Python SDK validate model names before sending requests?

No. The SDK performs no client-side validation of the `model` parameter string. As shown in [`src/openai/_client.py`](https://github.com/openai/openai-python/blob/main/src/openai/_client.py), the client forwards the value directly to OpenAI's servers, which return an error only if the model identifier is invalid or deprecated. This design allows immediate access to new models without SDK updates.

### Why does text-davinci-003 require a lower temperature setting than legacy Davinci?

Because `text-davinci-003` underwent instruction tuning and RLHF optimization, it generates more deterministic, focused responses aligned with prompt intent. Legacy Davinci relies on statistical text continuation, often requiring higher `temperature` values (0.7-1.0) to produce creative variance, whereas the newer model performs optimally with conservative temperatures (0.0-0.5) to leverage its trained obedience to instructions.

### Is text-davinci-003 deprecated in favor of GPT-3.5 Turbo?

Yes. While `text-davinci-003` remains accessible, OpenAI officially recommends `gpt-3.5-turbo` for nearly all use cases previously served by `text-davinci-003`. The turbo models offer superior performance at lower cost through the Chat Completions API, though they require migrating from the completion-style prompts used with `text-davinci-003` to the chat-based message format.