docs: rewrite getting started page

- Add core functions table (completion, responses, embedding, etc.)
- Update all examples to use provider/model format
- Update models to current versions (gpt-4o, claude-sonnet-4)
- Add Responses API example
- Add Embeddings example
- Add Async example
- Fix deprecated OpenAI import (openai.error -> openai)
- Update Next Steps links
- Address confusion from GitHub discussion #16638

Author: Chesars

docs/my-website/docs/getting_started.md

@@ -1,108 +1,169 @@
 # Getting Started
 
-import QuickStart from '../src/components/QuickStart.js'
+LiteLLM provides a unified SDK to call 100+ LLM providers using OpenAI-compatible formats.
 
-LiteLLM simplifies LLM API calls by mapping them all to the [OpenAI ChatCompletion format](https://platform.openai.com/docs/api-reference/chat).
+## Core Functions
 
-## basic usage
+| Function | OpenAI Endpoint | Use Case |
+|----------|-----------------|----------|
+| `completion()` | `/chat/completions` | Chat & text generation |
+| `responses()` | `/responses` | Reasoning models (o1, o3) |
+| `embedding()` | `/embeddings` | Vector embeddings |
+| `image_generation()` | `/images/generations` | Image creation |
+| `transcription()` | `/audio/transcriptions` | Speech-to-text |
 
-By default we provide a free $10 community-key to try all providers supported on LiteLLM.
+All functions use the format `provider/model` and return OpenAI-compatible responses.
+
+## Installation
+
+```shell
+pip install litellm
+```
+
+## Basic Usage
 
 ```python
 from litellm import completion
+import os
 
-## set ENV variables
+# Set your API key
 os.environ["OPENAI_API_KEY"] = "your-api-key"
-os.environ["COHERE_API_KEY"] = "your-api-key"
 
-messages = [{ "content": "Hello, how are you?","role": "user"}]
+messages = [{"role": "user", "content": "Hello, how are you?"}]
 
-# openai call
-response = completion(model="gpt-3.5-turbo", messages=messages)
+# Use provider/model format
+response = completion(
+    model="openai/gpt-4o",
+    messages=messages
+)
 
-# cohere call
-response = completion("command-nightly", messages)
+print(response.choices[0].message.content)
 ```
 
-**Need a dedicated key?**
-Email us @ krrish@berri.ai
+### Switch Providers with One Line
+
+```python
+import os
+from litellm import completion
+
+os.environ["OPENAI_API_KEY"] = "your-openai-key"
+os.environ["ANTHROPIC_API_KEY"] = "your-anthropic-key"
 
-Next Steps 👉 [Call all supported models - e.g. Claude-2, Llama2-70b, etc.](./proxy_api.md#supported-models)
+messages = [{"role": "user", "content": "Hello!"}]
 
-More details 👉
+# Same code, different providers
+response = completion(model="openai/gpt-4o", messages=messages)
+response = completion(model="anthropic/claude-sonnet-4-20250514", messages=messages)
 
-- [Completion() function details](./completion/)
-- [Overview of supported models / providers on LiteLLM](./providers/)
-- [Search all models / providers](https://models.litellm.ai/)
-- [Build your own OpenAI proxy](https://github.com/BerriAI/liteLLM-proxy/tree/main)
+# Both return the same OpenAI-compatible format
+print(response.choices[0].message.content)
+```
 
-## streaming
+## Streaming
 
-Same example from before. Just pass in `stream=True` in the completion args.
+Pass `stream=True` to get a streaming iterator:
 
 ```python
 from litellm import completion
 
-## set ENV variables
-os.environ["OPENAI_API_KEY"] = "openai key"
-os.environ["COHERE_API_KEY"] = "cohere key"
+response = completion(
+    model="openai/gpt-4o",
+    messages=[{"role": "user", "content": "Write a short poem"}],
+    stream=True
+)
+
+for chunk in response:
+    print(chunk.choices[0].delta.content or "", end="")
+```
+
+## Async
+
+Use `acompletion()` for async operations:
+
+```python
+from litellm import acompletion
+import asyncio
+
+async def main():
+    response = await acompletion(
+        model="openai/gpt-4o",
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+    print(response.choices[0].message.content)
 
-messages = [{ "content": "Hello, how are you?","role": "user"}]
+asyncio.run(main())
+```
 
-# openai call
-response = completion(model="gpt-3.5-turbo", messages=messages, stream=True)
+## Responses API
 
-# cohere call
-response = completion("command-nightly", messages, stream=True)
+For reasoning models (o1, o3) or OpenAI's new `/responses` format:
 
-print(response)
+```python
+import litellm
+
+response = litellm.responses(
+    model="openai/gpt-4o",
+    input="Tell me a bedtime story"
+)
+
+print(response.output[0].content[0].text)
 ```
 
-More details 👉
+Works with all providers - LiteLLM handles the translation automatically.
+
+## Embeddings
 
-- [streaming + async](./completion/stream.md)
-- [tutorial for streaming Llama2 on TogetherAI](./tutorials/TogetherAI_liteLLM.md)
+```python
+from litellm import embedding
+
+response = embedding(
+    model="openai/text-embedding-3-small",
+    input=["Hello world", "How are you?"]
+)
+
+print(response.data[0]["embedding"][:5]) 
+```
 
-## exception handling
+## Exception Handling
 
-LiteLLM maps exceptions across all supported providers to the OpenAI exceptions. All our exceptions inherit from OpenAI's exception types, so any error-handling you have for that, should work out of the box with LiteLLM.
+LiteLLM maps all provider exceptions to OpenAI-compatible exceptions:
 
 ```python
-from openai.error import OpenAIError
+from openai import OpenAIError
 from litellm import completion
 
-os.environ["ANTHROPIC_API_KEY"] = "bad-key"
 try:
-    # some code
-    completion(model="claude-instant-1", messages=[{"role": "user", "content": "Hey, how's it going?"}])
+    response = completion(
+        model="anthropic/claude-sonnet-4-20250514",
+        messages=[{"role": "user", "content": "Hello"}]
+    )
 except OpenAIError as e:
-    print(e)
+    print(f"Error: {e}")
 ```
 
-## Logging Observability - Log LLM Input/Output ([Docs](https://docs.litellm.ai/docs/observability/callbacks))
+## Observability
 
-LiteLLM exposes pre defined callbacks to send data to MLflow, Lunary, Langfuse, Helicone, Promptlayer, Traceloop, Slack
+Log LLM calls to Langfuse, Lunary, MLflow, and more:
 
 ```python
+import litellm
 from litellm import completion
 
-## set env variables for logging tools (API key set up is not required when using MLflow)
-os.environ["LUNARY_PUBLIC_KEY"] = "your-lunary-public-key" # get your public key at https://app.lunary.ai/settings
-os.environ["HELICONE_API_KEY"] = "your-helicone-key"
-os.environ["LANGFUSE_PUBLIC_KEY"] = ""
-os.environ["LANGFUSE_SECRET_KEY"] = ""
+# Set callbacks
+litellm.success_callback = ["langfuse", "lunary"]
 
-os.environ["OPENAI_API_KEY"]
-
-# set callbacks
-litellm.success_callback = ["lunary", "mlflow", "langfuse", "helicone"] # log input/output to MLflow, langfuse, lunary, helicone
-
-#openai call
-response = completion(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "Hi 👋 - i'm openai"}])
+response = completion(
+    model="openai/gpt-4o",
+    messages=[{"role": "user", "content": "Hello!"}]
+)
 ```
 
-More details 👉
+More details: [Observability & Logging](./observability/callbacks)
+
+## Next Steps
 
-- [exception mapping](./exception_mapping.md)
-- [retries + model fallbacks for completion()](./completion/reliable_completions.md)
-- [tutorial for model fallbacks with completion()](./tutorials/fallbacks.md)
+- [All Providers](./providers/) - Provider-specific documentation
+- [Supported Endpoints](./supported_endpoints) - Full list of supported endpoints
+- [LiteLLM Proxy](./simple_proxy) - Deploy as an API gateway with load balancing
+- [Router](./routing) - Load balancing & fallbacks
+- [Caching](./caching/) - Response caching