openai sdk
**OpenAI SDK** is the **official Python and TypeScript client library for the OpenAI API — providing type-safe access to GPT models, DALL-E image generation, Whisper transcription, embeddings, and fine-tuning endpoints** — with synchronous, asynchronous, and streaming interfaces that serve as the de facto standard for LLM API integration across the industry.
**What Is the OpenAI SDK?**
- **Definition**: The official client library (openai Python package, openai npm package) maintained by OpenAI for interacting with their REST API — handling authentication, HTTP communication, error handling, retries, and response parsing.
- **Python SDK (v1.0+)**: Introduced in late 2023, the v1.0 rewrite moved from module-level functions to a client object pattern — `client = OpenAI()` then `client.chat.completions.create()` — with strict typing via Pydantic and better IDE completion.
- **TypeScript/Node SDK**: The `openai` npm package mirrors the Python API exactly — same method names, same parameter names — enabling easy skill transfer between languages.
- **OpenAI-Compatible Standard**: The OpenAI API format has become the industry standard — LiteLLM, Ollama, Azure OpenAI, Together AI, Anyscale, and dozens of other providers expose OpenAI-compatible endpoints, making SDK knowledge universally applicable.
- **Async Support**: Full async/await support via `AsyncOpenAI` client — critical for high-throughput applications processing thousands of concurrent API calls.
**Why the OpenAI SDK Matters**
- **Industry Standard Interface**: Learning the OpenAI SDK means understanding the interface that powers the majority of production LLM applications — Azure OpenAI, Together AI, Groq, and Anyscale all use the same API format.
- **Type Safety**: v1.0+ SDK uses Pydantic models for all responses — IDE autocomplete, runtime validation, and no more raw dictionary access with potential KeyError.
- **Streaming**: First-class streaming support enables real-time response display — users see tokens as they generate rather than waiting for the full completion.
- **Built-in Retries**: Automatic exponential backoff and retry on rate limit errors (429) and server errors (500/503) — production reliability without custom retry logic.
- **Tool Use / Function Calling**: Structured tool calling enables LLMs to request data from external systems — the foundation for all agent frameworks.
**Core Usage Patterns**
**Basic Chat Completion**:
```python
from openai import OpenAI
client = OpenAI() # Uses OPENAI_API_KEY env variable
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Explain quantum entanglement simply."}
],
max_tokens=500,
temperature=0.7
)
print(response.choices[0].message.content)
```
**Streaming Response**:
```python
with client.chat.completions.stream(model="gpt-4o", messages=[...]) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
```
**Tool Calling (Function Calling)**:
```python
tools = [{"type": "function", "function": {
"name": "get_weather",
"parameters": {"type": "object", "properties": {"city": {"type": "string"}}}
}}]
response = client.chat.completions.create(model="gpt-4o", messages=[...], tools=tools)
# Check response.choices[0].message.tool_calls for tool invocation
```
**Async Usage**:
```python
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def fetch(prompt):
return await async_client.chat.completions.create(model="gpt-4o-mini", messages=[{"role":"user","content":prompt}])
```
**Embeddings**:
```python
embedding = client.embeddings.create(model="text-embedding-3-small", input="Sample text")
vector = embedding.data[0].embedding # 1536-dimensional float list
```
**Key API Capabilities**
- **Chat Completions**: Multi-turn conversation with system, user, and assistant roles — the core interface for all conversational AI.
- **Structured Outputs**: Pass a JSON schema or Pydantic model via `response_format` — guaranteed valid structured output (no Instructor needed for simple schemas).
- **Embeddings**: Convert text to high-dimensional vectors for semantic search, clustering, and classification.
- **DALL-E 3 Image Generation**: Generate and edit images from text prompts via `client.images.generate()`.
- **Whisper Transcription**: Audio file to text via `client.audio.transcriptions.create()`.
- **Fine-Tuning**: Upload training data and fine-tune GPT-4o-mini or GPT-3.5 via `client.fine_tuning.jobs.create()`.
- **Batch API**: Submit thousands of requests for 50% cost reduction with 24-hour processing via `client.batches.create()`.
**SDK v0 vs v1 Migration**
| Old (v0) | New (v1+) |
|---------|---------|
| `openai.ChatCompletion.create()` | `client.chat.completions.create()` |
| `openai.api_key = "sk-..."` | `client = OpenAI(api_key="sk-...")` |
| Dict responses | Typed Pydantic objects |
| No async client | `AsyncOpenAI()` |
The OpenAI SDK is **the lingua franca of LLM application development** — mastering its patterns for streaming, tool calling, structured outputs, and async usage provides skills that transfer directly to Azure OpenAI, Groq, Together AI, and any other OpenAI-compatible provider, making it the most leveraged API investment in the AI engineering toolkit.