docs: Update documentation for Venice Large 128k context window

- Add Venice Large model examples and context window guidance to README.md
- Update client utilities documentation with model capability notes
- Enhance async streaming guide with large context usage examples
- Bump version to 1.1.2
- Update CHANGELOG with comprehensive release notes

Reflects API improvements:
- Venice Large context increased from 32k to 128k tokens
- Server-side thinking message processing improvements

Author: sethbang

CHANGELOG.md

@@ -5,6 +5,24 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.2] - 2025-06-19
+
+### Changed
+
+- **Documentation Updates**: Updated documentation to reflect Venice.ai API improvements
+  - Added information about Venice Large model's increased context window (32k → 128k tokens)
+  - Enhanced `README.md` with Venice Large examples and context window guidance
+  - Updated `docs/client_utilities.rst` with model capability notes and token management best practices
+  - Enhanced `docs/async_chat_streaming_guide.rst` with large context window usage guidance
+  - Added practical examples showing how to leverage the 128k context window with `max_completion_tokens`
+
+### Notes
+
+- **API Compatibility**: No SDK code changes required - existing functionality automatically benefits from API improvements
+  - Venice Large's increased context size can be utilized through existing `max_completion_tokens` parameter
+  - Non-streaming chat completions now receive cleaner responses due to server-side "thinking" message processing improvements
+  - Streaming behavior remains unchanged and continues to pass through all API-sent events
+
 ## [1.1.1] - 2025-06-13
 
 ### Fixed

README.md

@@ -199,6 +199,10 @@ It's important to `close()` (for `VeniceClient`) or `await async_client.close()`
 
 The response objects (`response`, `chunk`) are `TypedDict`s. You can explore their structure for more details (see `src/venice_ai/types/chat.py` or the Sphinx-generated API documentation).
 
+**Model Context Windows:**
+
+Different models support different context window sizes. For example, the "Venice Large" model supports up to 128k tokens, allowing for extensive conversations or document processing. Use the `max_completion_tokens` parameter to control response length within the model's context limits.
+
 **Parameters:**
 
 :param logprobs: Whether to return log probabilities of the output tokens. If `True`, the `logprobs` field will be populated in the `choices` of the response. Defaults to `False`.
@@ -222,6 +226,24 @@ with VeniceClient() as client:
     print(response.choices[0].message.content)
 ```
 
+**Example with Venice Large (128k context window):**
+
+```python
+from venice_ai import VeniceClient
+
+with VeniceClient() as client:
+    # Venice Large supports up to 128k tokens, ideal for long documents or conversations
+    response = client.chat.completions.create(
+        model="venice-large",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant that can analyze long documents."},
+            {"role": "user", "content": "Please analyze this extensive document..."}  # Can include very long content
+        ],
+        max_completion_tokens=4000  # Can use higher values with Venice Large's 128k context
+    )
+    print(response.choices[0].message.content)
+```
+
 **Example with `logprobs` and `top_logprobs`:**
 
 ```python
@@ -435,6 +457,8 @@ with VeniceClient() as client:
     print(f"Text models: {[m.id for m in text_models.data]}")
 ```
 
+**Note:** Different models have varying capabilities and context window sizes. For example, "Venice Large" supports up to 128k tokens, making it ideal for processing extensive documents or maintaining long conversations. Refer to the official Venice AI documentation for detailed specifications of each model.
+
 ### API Key Management
 
 ```python

docs/async_chat_streaming_guide.rst

@@ -119,6 +119,7 @@ Further Exploration
 -------------------
 
 - Explore other parameters of the `create` method to customize model behavior (e.g., `temperature`, `max_completion_tokens`).
+- When using models with larger context windows like "Venice Large" (128k tokens), you can adjust `max_completion_tokens` accordingly to leverage the full context for longer responses or more detailed analysis.
 - Integrate this streaming logic into a web application or a command-line interface for a more interactive experience.
 - Refer to the :ref:`API Reference <api_reference>` for detailed information on all available methods and parameters.
 

docs/client_utilities.rst

@@ -67,6 +67,8 @@ Model Utilities
     # Run the async example
     asyncio.run(example_model_utilities())
 
+**Note:** For detailed specifications of individual models, such as context window size (e.g., "Venice Large" supports up to 128k tokens), refer to the official Venice AI model documentation. Different models have varying capabilities that may affect your application's design.
+
 Chat Message Utilities
 ~~~~~~~~~~~~~~~~~~~~~~
 
@@ -130,5 +132,5 @@ Best Practices
 
 - **Error Handling**: Always check for errors when using validation functions.
 - **Capabilities Checking**: Use the model utility functions to ensure you're working with models that support your required features.
-- **Token Management**: Use ``estimate_token_count`` to proactively manage token usage within limits.
+- **Token Management**: Use ``estimate_token_count`` to proactively manage token usage, especially when working with models with large context windows like "Venice Large" (128k tokens), to stay within API and model limits.
 - **Async Consistency**: Most model utility functions are async and should be awaited properly.

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "venice-ai"
-version = "1.1.1"
+version = "1.1.2"
 description = "Python client library for interacting with the Venice.ai API, offering comprehensive access to its features."
 readme = "README.md"
 license = "MIT"