Remove 'only on 3.10+' callouts (#2733)

Author: DouweM

docs/ag-ui.md

@@ -119,7 +119,7 @@ This will expose the agent as an AG-UI server, and your frontend can start sendi
 
 This example uses [`Agent.to_ag_ui()`][pydantic_ai.agent.AbstractAgent.to_ag_ui] to turn the agent into a stand-alone ASGI application:
 
-```py {title="agent_to_ag_ui.py" py="3.10" hl_lines="4"}
+```py {title="agent_to_ag_ui.py" hl_lines="4"}
 from pydantic_ai import Agent
 
 agent = Agent('openai:gpt-4.1', instructions='Be fun!')
@@ -171,7 +171,7 @@ validate state contained in [`RunAgentInput.state`](https://docs.ag-ui.com/sdk/j
     If the `state` field's type is a Pydantic `BaseModel` subclass, the raw state dictionary on the request is automatically validated. If not, you can validate the raw value yourself in your dependencies dataclass's `__post_init__` method.
 
 
-```python {title="ag_ui_state.py" py="3.10"}
+```python {title="ag_ui_state.py"}
 from pydantic import BaseModel
 
 from pydantic_ai import Agent
@@ -211,7 +211,7 @@ which returns a (subclass of)
 [`BaseEvent`](https://docs.ag-ui.com/sdk/python/core/events#baseevent), which allows
 for custom events and state updates.
 
-```python {title="ag_ui_tool_events.py" py="3.10"}
+```python {title="ag_ui_tool_events.py"}
 from ag_ui.core import CustomEvent, EventType, StateSnapshotEvent
 from pydantic import BaseModel
 

docs/examples/weather-agent.md

@@ -35,7 +35,6 @@ Here's what the UI looks like for the weather agent:
 
 {{ video('c549d8d8827ded15f326f998e428e6c3', 6) }}
 
-Note, to run the UI, you'll need Python 3.10+.
 
 ```bash
 pip install gradio>=5.9.0

docs/graph.md

@@ -122,7 +122,7 @@ class MyNode(BaseNode[MyState, None, int]):  # (1)!
 
 Here's an example of a simple graph:
 
-```py {title="graph_example.py" py="3.10"}
+```py {title="graph_example.py"}
 from __future__ import annotations
 
 from dataclasses import dataclass
@@ -163,11 +163,11 @@ print(result.output)
 3. The graph is created with a sequence of nodes.
 4. The graph is run synchronously with [`run_sync`][pydantic_graph.graph.Graph.run_sync]. The initial node is `DivisibleBy5(4)`. Because the graph doesn't use external state or deps, we don't pass `state` or `deps`.
 
-_(This example is complete, it can be run "as is" with Python 3.10+)_
+_(This example is complete, it can be run "as is")_
 
 A [mermaid diagram](#mermaid-diagrams) for this graph can be generated with the following code:
 
-```py {title="graph_example_diagram.py" py="3.10" requires="graph_example.py"}
+```py {title="graph_example_diagram.py" requires="graph_example.py"}
 from graph_example import DivisibleBy5, fives_graph
 
 fives_graph.mermaid_code(start_node=DivisibleBy5)
@@ -201,7 +201,7 @@ The "state" concept in `pydantic-graph` provides an optional way to access and m
 
 Here's an example of a graph which represents a vending machine where the user may insert coins and select a product to purchase.
 
-```python {title="vending_machine.py" py="3.10"}
+```python {title="vending_machine.py"}
 from __future__ import annotations
 
 from dataclasses import dataclass
@@ -304,11 +304,11 @@ async def main():
 17. The return type of `CoinsInserted`'s [`run`][pydantic_graph.nodes.BaseNode.run] method is a union, meaning multiple outgoing edges are possible.
 18. Unlike other nodes, `Purchase` can end the run, so the [`RunEndT`][pydantic_graph.nodes.RunEndT] generic parameter must be set. In this case it's `None` since the graph run return type is `None`.
 
-_(This example is complete, it can be run "as is" with Python 3.10+ — you'll need to add `asyncio.run(main())` to run `main`)_
+_(This example is complete, it can be run "as is" — you'll need to add `asyncio.run(main())` to run `main`)_
 
 A [mermaid diagram](#mermaid-diagrams) for this graph can be generated with the following code:
 
-```py {title="vending_machine_diagram.py" py="3.10" requires="vending_machine.py"}
+```py {title="vending_machine_diagram.py" requires="vending_machine.py"}
 from vending_machine import InsertCoin, vending_machine_graph
 
 vending_machine_graph.mermaid_code(start_node=InsertCoin)
@@ -352,7 +352,7 @@ stateDiagram-v2
   Feedback --> [*]
 ```
 
-```python {title="genai_email_feedback.py" py="3.10"}
+```python {title="genai_email_feedback.py"}
 from __future__ import annotations as _annotations
 
 from dataclasses import dataclass, field
@@ -466,7 +466,7 @@ async def main():
     """
 ```
 
-_(This example is complete, it can be run "as is" with Python 3.10+ — you'll need to add `asyncio.run(main())` to run `main`)_
+_(This example is complete, it can be run "as is" — you'll need to add `asyncio.run(main())` to run `main`)_
 
 ## Iterating Over a Graph
 
@@ -476,7 +476,7 @@ Sometimes you want direct control or insight into each node as the graph execute
 
 Here's an example:
 
-```python {title="count_down.py" noqa="I001" py="3.10"}
+```python {title="count_down.py" noqa="I001"}
 from __future__ import annotations as _annotations
 
 from dataclasses import dataclass
@@ -524,7 +524,7 @@ Alternatively, you can drive iteration manually with the [`GraphRun.next`][pydan
 
 Below is a contrived example that stops whenever the counter is at 2, ignoring any node runs beyond that:
 
-```python {title="count_down_next.py" noqa="I001" py="3.10" requires="count_down.py"}
+```python {title="count_down_next.py" noqa="I001" requires="count_down.py"}
 from pydantic_graph import End, FullStatePersistence
 from count_down import CountDown, CountDownState, count_down_graph
 
@@ -593,7 +593,7 @@ We can run the `count_down_graph` from [above](#iterating-over-a-graph), using [
 
 As you can see in this code, `run_node` requires no external application state (apart from state persistence) to be run, meaning graphs can easily be executed by distributed execution and queueing systems.
 
-```python {title="count_down_from_persistence.py" noqa="I001" py="3.10" requires="count_down.py"}
+```python {title="count_down_from_persistence.py" noqa="I001" requires="count_down.py"}
 from pathlib import Path
 
 from pydantic_graph import End
@@ -637,7 +637,7 @@ async def run_node(run_id: str) -> bool:  # (3)!
 5. [`graph.run()`][pydantic_graph.graph.Graph.run] will return either a [node][pydantic_graph.nodes.BaseNode] or an [`End`][pydantic_graph.nodes.End] object.
 6. Check if the node is an [`End`][pydantic_graph.nodes.End] object, if it is, the graph run is complete.
 
-_(This example is complete, it can be run "as is" with Python 3.10+ — you'll need to add `asyncio.run(main())` to run `main`)_
+_(This example is complete, it can be run "as is" — you'll need to add `asyncio.run(main())` to run `main`)_
 
 ### Example: Human in the loop.
 
@@ -648,7 +648,7 @@ In this example, an AI asks the user a question, the user provides an answer, th
 Instead of running the entire graph in a single process invocation, we run the graph by running the process repeatedly, optionally providing an answer to the question as a command line argument.
 
 ??? example "`ai_q_and_a_graph.py` — `question_graph` definition"
-```python {title="ai_q_and_a_graph.py" noqa="I001" py="3.10"}
+```python {title="ai_q_and_a_graph.py" noqa="I001"}
 from __future__ import annotations as _annotations
 
 from typing import Annotated
@@ -748,9 +748,9 @@ question_graph = Graph(
 )
 ```
 
-_(This example is complete, it can be run "as is" with Python 3.10+)_
+_(This example is complete, it can be run "as is")_
 
-```python {title="ai_q_and_a_run.py" noqa="I001" py="3.10" requires="ai_q_and_a_graph.py"}
+```python {title="ai_q_and_a_run.py" noqa="I001" requires="ai_q_and_a_graph.py"}
 import sys
 from pathlib import Path
 
@@ -799,7 +799,7 @@ async def main():
 8. To demonstrate the state persistence, we call [`load_all`][pydantic_graph.persistence.BaseStatePersistence.load_all] to get all the snapshots from the persistence instance. This will return a list of [`Snapshot`][pydantic_graph.persistence.Snapshot] objects.
 9. If the node is an `Answer` object, we print the question and break out of the loop to end the process and wait for user input.
 
-_(This example is complete, it can be run "as is" with Python 3.10+ — you'll need to add `asyncio.run(main())` to run `main`)_
+_(This example is complete, it can be run "as is" — you'll need to add `asyncio.run(main())` to run `main`)_
 
 For a complete example of this graph, see the [question graph example](examples/question-graph.md).
 
@@ -809,7 +809,7 @@ As with Pydantic AI, `pydantic-graph` supports dependency injection via a generi
 
 As an example of dependency injection, let's modify the `DivisibleBy5` example [above](#graph) to use a [`ProcessPoolExecutor`][concurrent.futures.ProcessPoolExecutor] to run the compute load in a separate process (this is a contrived example, `ProcessPoolExecutor` wouldn't actually improve performance in this example):
 
-```py {title="deps_example.py" py="3.10" test="skip" hl_lines="4 10-12 35-37 48-49"}
+```py {title="deps_example.py" test="skip" hl_lines="4 10-12 35-37 48-49"}
 from __future__ import annotations
 
 import asyncio
@@ -877,7 +877,7 @@ async def main():
     """
 ```
 
-_(This example is complete, it can be run "as is" with Python 3.10+ — you'll need to add `asyncio.run(main())` to run `main`)_
+_(This example is complete, it can be run "as is" — you'll need to add `asyncio.run(main())` to run `main`)_
 
 ## Mermaid Diagrams
 
@@ -1025,7 +1025,7 @@ You can specify the direction of the state diagram using one of the following va
 
 Here is an example of how to do this using 'Left to Right' (LR) instead of the default 'Top to Bottom' (TB):
 
-```py {title="vending_machine_diagram.py" py="3.10" requires="vending_machine.py"}
+```py {title="vending_machine_diagram.py" requires="vending_machine.py"}
 from vending_machine import InsertCoin, vending_machine_graph
 
 vending_machine_graph.mermaid_code(start_node=InsertCoin, direction='LR')

docs/mcp/client.md

@@ -11,9 +11,6 @@ You need to either install [`pydantic-ai`](../install.md), or[`pydantic-ai-slim`
 pip/uv-add "pydantic-ai-slim[mcp]"
 ```
 
-!!! note
-    MCP integration requires Python 3.10 or higher.
-
 ## Usage
 
 Pydantic AI comes with two ways to connect to MCP servers:
@@ -38,7 +35,7 @@ You can use the [`async with agent`][pydantic_ai.Agent.__aenter__] context manag
 
 Before creating the Streamable HTTP client, we need to run a server that supports the Streamable HTTP transport.
 
-```python {title="streamable_http_server.py" py="3.10" dunder_name="not_main"}
+```python {title="streamable_http_server.py" dunder_name="not_main"}
 from mcp.server.fastmcp import FastMCP
 
 app = FastMCP()
@@ -53,7 +50,7 @@ if __name__ == '__main__':
 
 Then we can create the client:
 
-```python {title="mcp_streamable_http_client.py" py="3.10"}
+```python {title="mcp_streamable_http_client.py"}
 from pydantic_ai import Agent
 from pydantic_ai.mcp import MCPServerStreamableHTTP
 
@@ -71,7 +68,7 @@ async def main():
 2. Create an agent with the MCP server attached.
 3. Create a client session to connect to the server.
 
-_(This example is complete, it can be run "as is" with Python 3.10+ — you'll need to add `asyncio.run(main())` to run `main`)_
+_(This example is complete, it can be run "as is" — you'll need to add `asyncio.run(main())` to run `main`)_
 
 **What's happening here?**
 
@@ -113,7 +110,7 @@ deno run \
   jsr:@pydantic/mcp-run-python sse
 ```
 
-```python {title="mcp_sse_client.py" py="3.10"}
+```python {title="mcp_sse_client.py"}
 from pydantic_ai import Agent
 from pydantic_ai.mcp import MCPServerSSE
 
@@ -132,13 +129,13 @@ async def main():
 2. Create an agent with the MCP server attached.
 3. Create a client session to connect to the server.
 
-_(This example is complete, it can be run "as is" with Python 3.10+ — you'll need to add `asyncio.run(main())` to run `main`)_
+_(This example is complete, it can be run "as is" — you'll need to add `asyncio.run(main())` to run `main`)_
 
 ### MCP "stdio" Server
 
 The other transport offered by MCP is the [stdio transport](https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#stdio) where the server is run as a subprocess and communicates with the client over `stdin` and `stdout`. In this case, you'd use the [`MCPServerStdio`][pydantic_ai.mcp.MCPServerStdio] class.
 
-```python {title="mcp_stdio_client.py" py="3.10"}
+```python {title="mcp_stdio_client.py"}
 from pydantic_ai import Agent
 from pydantic_ai.mcp import MCPServerStdio
 
@@ -174,7 +171,7 @@ the customisation of tool call requests and their responses.
 A common use case for this is to inject metadata to the requests which the server
 call needs.
 
-```python {title="mcp_process_tool_call.py" py="3.10"}
+```python {title="mcp_process_tool_call.py"}
 from typing import Any
 
 from pydantic_ai import Agent
@@ -214,7 +211,7 @@ When connecting to multiple MCP servers that might provide tools with the same n
 
 This allows you to use multiple servers that might have overlapping tool names without conflicts:
 
-```python {title="mcp_tool_prefix_http_client.py" py="3.10"}
+```python {title="mcp_tool_prefix_http_client.py"}
 from pydantic_ai import Agent
 from pydantic_ai.mcp import MCPServerSSE
 
@@ -247,7 +244,7 @@ All HTTP-based MCP client classes
 parameter that lets you pass your own pre-configured
 [`httpx.AsyncClient`](https://www.python-httpx.org/async/).
 
-```python {title="mcp_custom_tls_client.py" py="3.10"}
+```python {title="mcp_custom_tls_client.py"}
 import httpx
 import ssl
 
@@ -324,7 +321,7 @@ Let's say we have an MCP server that wants to use sampling (in this case to gene
 
 ??? example "Sampling MCP Server"
 
-    ```python {title="generate_svg.py" py="3.10"}
+    ```python {title="generate_svg.py"}
     import re
     from pathlib import Path
 
@@ -362,7 +359,7 @@ Let's say we have an MCP server that wants to use sampling (in this case to gene
 
 Using this server with an `Agent` will automatically allow sampling:
 
-```python {title="sampling_mcp_client.py" py="3.10" requires="generate_svg.py"}
+```python {title="sampling_mcp_client.py" requires="generate_svg.py"}
 from pydantic_ai import Agent
 from pydantic_ai.mcp import MCPServerStdio
 
@@ -378,11 +375,11 @@ async def main():
     #> Image file written to robot_punk.svg.
 ```
 
-_(This example is complete, it can be run "as is" with Python 3.10+)_
+_(This example is complete, it can be run "as is")_
 
 You can disallow sampling by setting [`allow_sampling=False`][pydantic_ai.mcp.MCPServer.allow_sampling] when creating the server reference, e.g.:
 
-```python {title="sampling_disallowed.py" hl_lines="6" py="3.10"}
+```python {title="sampling_disallowed.py" hl_lines="6"}
 from pydantic_ai.mcp import MCPServerStdio
 
 server = MCPServerStdio(
@@ -418,7 +415,7 @@ This allows for a more interactive and user-friendly experience, especially for
 
 To enable elicitation, provide an [`elicitation_callback`][pydantic_ai.mcp.MCPServer.elicitation_callback] function when creating your MCP server instance:
 
-```python {title="restaurant_server.py" py="3.10"}
+```python {title="restaurant_server.py"}
 from mcp.server.fastmcp import Context, FastMCP
 from pydantic import BaseModel, Field
 
@@ -454,7 +451,7 @@ if __name__ == '__main__':
 
 This server demonstrates elicitation by requesting structured booking details from the client when the `book_table` tool is called. Here's how to create a client that handles these elicitation requests:
 
-```python {title="client_example.py" py="3.10" requires="restaurant_server.py" test="skip"}
+```python {title="client_example.py" requires="restaurant_server.py" test="skip"}
 import asyncio
 from typing import Any
 

docs/mcp/run-python.md

@@ -52,7 +52,7 @@ Usage of `jsr:@pydantic/mcp-run-python` with Pydantic AI is described in the [cl
 
 As well as using this server with Pydantic AI, it can be connected to other MCP clients. For clarity, in this example we connect directly using the [Python MCP client](https://github.com/modelcontextprotocol/python-sdk).
 
-```python {title="mcp_run_python.py" py="3.10"}
+```python {title="mcp_run_python.py"}
 from mcp import ClientSession, StdioServerParameters
 from mcp.client.stdio import stdio_client
 
@@ -127,7 +127,7 @@ As introduced in PEP 723, explained [here](https://packaging.python.org/en/lates
 
 This allows use of dependencies that aren't imported in the code, and is more explicit.
 
-```py {title="inline_script_metadata.py" py="3.10" requires="mcp_run_python.py"}
+```py {title="inline_script_metadata.py" requires="mcp_run_python.py"}
 from mcp import ClientSession
 from mcp.client.stdio import stdio_client
 

docs/mcp/server.md

@@ -6,7 +6,7 @@ Pydantic AI models can also be used within MCP Servers.
 
 Here's a simple example of a [Python MCP server](https://github.com/modelcontextprotocol/python-sdk) using Pydantic AI within a tool call:
 
-```py {title="mcp_server.py" py="3.10"}
+```py {title="mcp_server.py"}
 from mcp.server.fastmcp import FastMCP
 
 from pydantic_ai import Agent
@@ -32,7 +32,7 @@ if __name__ == '__main__':
 
 This server can be queried with any MCP client. Here is an example using the Python SDK directly:
 
-```py {title="mcp_client.py" py="3.10" requires="mcp_server.py" dunder_name="not_main"}
+```py {title="mcp_client.py" requires="mcp_server.py" dunder_name="not_main"}
 import asyncio
 import os
 
@@ -70,7 +70,7 @@ When Pydantic AI agents are used within MCP servers, they can use sampling via [
 
 We can extend the above example to use sampling so instead of connecting directly to the LLM, the agent calls back through the MCP client to make LLM calls.
 
-```py {title="mcp_server_sampling.py" py="3.10"}
+```py {title="mcp_server_sampling.py"}
 from mcp.server.fastmcp import Context, FastMCP
 
 from pydantic_ai import Agent
@@ -95,7 +95,7 @@ The [above](#simple-client) client does not support sampling, so if you tried to
 
 The simplest way to support sampling in an MCP client is to [use](./client.md#mcp-sampling) a Pydantic AI agent as the client, but if you wanted to support sampling with the vanilla MCP SDK, you could do so like this:
 
-```py {title="mcp_client_sampling.py" py="3.10" requires="mcp_server_sampling.py"}
+```py {title="mcp_client_sampling.py" requires="mcp_server_sampling.py"}
 import asyncio
 from typing import Any
 
@@ -150,4 +150,4 @@ if __name__ == '__main__':
     asyncio.run(client())
 ```
 
-_(This example is complete, it can be run "as is" with Python 3.10+)_
+_(This example is complete, it can be run "as is")_

pydantic_graph/README.md

@@ -19,7 +19,7 @@ Full documentation is available at [ai.pydantic.dev/graph](https://ai.pydantic.d
 
 Here's a basic example:
 
-```python {noqa="I001" py="3.10"}
+```python {noqa="I001"}
 from __future__ import annotations
 
 from dataclasses import dataclass