@@ -81,12 +81,14 @@ def _drop_optional_none_values(value: object, dumped: object) -> object:
     if isinstance(value, BaseModel):
         fields = type(value).model_fields
         schema_required = getattr(type(value), SCHEMA_REQUIRED_FIELDS_ATTR, frozenset())
+        # The dump is keyed by alias, which is the schema's name for a field Pydantic could not name after it
+        field_names = {field.alias or name: name for name, field in fields.items()}
         filtered = {}
-        # The dump is keyed by field name (no aliases), so each key maps back to its attribute.
         for key, item_dump in dumped.items():
-            item = getattr(value, key, item_dump)
+            name = field_names.get(key, key)
+            item = getattr(value, name, item_dump)
             if item is None:
-                if key in schema_required or (key in fields and fields[key].is_required()):
+                if key in schema_required or (name in fields and fields[name].is_required()):
                     filtered[key] = None
                 continue
             filtered[key] = _drop_optional_none_values(item, item_dump)
@@ -108,7 +110,7 @@ def _dump_tool_args(model: BaseModel) -> dict:
     reject those extra nulls. A required field keeps an explicit None: JSON Schema requires the key to be
     present, and null can be a valid value for it.
     """
-    return _drop_optional_none_values(model, model.model_dump(mode='json'))
+    return _drop_optional_none_values(model, model.model_dump(mode='json', by_alias=True))
 
 
 class PerUserMCPFunctionGroup(FunctionGroup):
 
@@ -178,6 +178,29 @@ def truncate_session_id(session_id: str, max_length: int = 10) -> str:
 SCHEMA_REQUIRED_FIELDS_ATTR = "__mcp_schema_required_fields__"
 
 
+def _field_names_for_properties(property_names: list[str]) -> dict[str, str]:
+    """Map each schema property name to the name of its Pydantic field.
+
+    JSON Schema allows any property name, but Pydantic rejects field names with a leading underscore (e.g. `_id`)
+    and names of its own `model_` members (e.g. `model_config`). Such a property gets a field named after it with
+    the leading underscores stripped and a trailing underscore added, and keeps its own name as the field alias.
+    Every other property keeps its name.
+    """
+    taken = set(property_names)
+    field_names = {}
+    for property_name in property_names:
+        if not property_name.startswith("_") and not (property_name.startswith("model_")
+                                                      and hasattr(BaseModel, property_name)):
+            field_names[property_name] = property_name
+            continue
+        field_name = (property_name.lstrip("_") or "field") + "_"
+        while field_name in taken:
+            field_name += "_"
+        taken.add(field_name)
+        field_names[property_name] = field_name
+    return field_names
+
+
 def model_from_mcp_schema(name: str, mcp_input_schema: dict) -> type[BaseModel]:
     """
     Create a pydantic model from the input schema of the MCP tool
@@ -403,7 +426,7 @@ def _has_null_in_type(field_properties: dict[str, Any]) -> bool:
 
         return False
 
-    def _generate_field(field_name: str, field_properties: dict[str, Any]) -> tuple:
+    def _generate_field(field_name: str, field_properties: dict[str, Any], aliased: bool = False) -> tuple:
         """
         Generate a Pydantic field from JSON schema properties.
         Uses _resolve_schema_type for type resolution and handles field-specific logic.
@@ -444,16 +467,28 @@ def _generate_field(field_name: str, field_properties: dict[str, Any]) -> tuple:
             field_type = field_type | None
 
         description = field_properties.get("description", "")
+        # A field Pydantic cannot name after its property keeps the property's name as its alias
+        alias_kwargs = {"alias": field_name} if aliased else {}
 
-        return field_type, Field(default=default_value, description=description, **_constraint_kwargs(field_properties))
+        return field_type, Field(default=default_value,
+                                 description=description,
+                                 **alias_kwargs,
+                                 **_constraint_kwargs(field_properties))
 
+    field_names = _field_names_for_properties(list(properties))
     for field_name, field_props in properties.items():
-        schema_dict[field_name] = _generate_field(field_name=field_name, field_properties=field_props)
-    model_config = None
+        schema_dict[field_names[field_name]] = _generate_field(field_name=field_name,
+                                                               field_properties=field_props,
+                                                               aliased=field_names[field_name] != field_name)
+    model_config = ConfigDict()
     if mcp_input_schema.get("additionalProperties") is False:
-        model_config = ConfigDict(extra="forbid")
+        model_config["extra"] = "forbid"
     elif mcp_input_schema.get("additionalProperties") is True:
-        model_config = ConfigDict(extra="allow")
+        model_config["extra"] = "allow"
+    if any(field_names[property_name] != property_name for property_name in properties):
+        # The input arrives keyed by the schema's names from the model, and by field name when NAT passes the
+        # validated input on as keyword arguments, so accept both
+        model_config["validate_by_name"] = True
 
     model = create_model(f"{_generate_valid_classname(name)}InputSchema", __config__=model_config, **schema_dict)
     # A field can declare a default and still be in `required`, so Pydantic alone cannot tell which keys the
 
@@ -480,6 +480,30 @@ async def tracking_ctx(session_id):
     "required": ["pet"],
 }
 
+_UNDERSCORE_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "_id": {
+            "type": "string"
+        },
+        "model_config": {
+            "type": "string"
+        },
+        "filter": {
+            "type": "object",
+            "properties": {
+                "_id": {
+                    "type": "string"
+                }, "_rev": {
+                    "type": "string"
+                }
+            },
+            "required": ["_id"],
+        },
+    },
+    "required": ["_id"],
+}
+
 
 class _RecordingTool:
     """Fake MCP tool that records the arguments sent to the server."""
@@ -582,3 +606,15 @@ async def test_discriminated_union_argument_is_sent_as_the_matching_variant(
     """The `const` tag selects the variant, so the call carries that variant's fields and defaults."""
     sent = await send_tool_args({"pet": {"pet_type": "dog", "name": "Rex"}}, _DISCRIMINATED_UNION_SCHEMA)
     assert sent == {"pet": {"pet_type": "dog", "name": "Rex", "good_boy": True, "lives": 1}}
+
+
+async def test_arguments_renamed_for_pydantic_are_sent_under_their_schema_names(send_tool_args):
+    """`_id` is a field named `id_` in the input schema, but the server expects the key `_id`."""
+    tool_args = {"_id": "doc-1", "model_config": "strict", "filter": {"_id": "doc-2"}}
+    sent = await send_tool_args(tool_args, _UNDERSCORE_SCHEMA)
+    assert sent == {"_id": "doc-1", "model_config": "strict", "filter": {"_id": "doc-2"}}
+
+
+async def test_renamed_optional_arguments_left_unset_are_not_sent(send_tool_args):
+    sent = await send_tool_args({"_id": "doc-1", "filter": {"_id": "doc-2"}}, _UNDERSCORE_SCHEMA)
+    assert sent == {"_id": "doc-1", "filter": {"_id": "doc-2"}}
@@ -1692,3 +1692,58 @@ def test_const_string_null_is_a_string_value():
     assert _model.model_validate({"mode": "null"}).mode == "null"
     with pytest.raises(ValidationError):
         _model.model_validate({"mode": "other"})
+
+
+@pytest.mark.parametrize("property_name, field_name", [("_id", "id_"), ("model_config", "model_config_")])
+def test_property_pydantic_cannot_name_a_field_after_keeps_its_name_as_alias(property_name: str, field_name: str):
+    """Pydantic rejects `_id` (common on MongoDB-style servers) and `model_config` as field names."""
+    schema = {"type": "object", "properties": {property_name: {"type": "string"}}, "required": [property_name]}
+
+    _model = model_from_mcp_schema(f"test_{property_name}_property", schema)
+
+    assert _model.model_fields[field_name].alias == property_name
+    assert list(_model.model_json_schema()["properties"]) == [property_name]
+    assert getattr(_model.model_validate({property_name: "doc-1"}), field_name) == "doc-1"
+    assert getattr(_model.model_validate({field_name: "doc-1"}), field_name) == "doc-1"
+    with pytest.raises(ValidationError):
+        _model.model_validate({})
+
+
+def test_renamed_field_does_not_take_the_name_of_another_property():
+    schema = {"type": "object", "properties": {"_id": {"type": "string"}, "id_": {"type": "integer"}}}
+
+    _model = model_from_mcp_schema("test_renamed_field_collision", schema)
+
+    assert {name: field.alias for name, field in _model.model_fields.items()} == {"id__": "_id", "id_": None}
+    assert _model.model_validate({"_id": "doc-1", "id_": 1}).model_dump(by_alias=True) == {"_id": "doc-1", "id_": 1}
+
+
+def test_nested_property_with_leading_underscore_keeps_its_name_as_alias():
+    schema = {
+        "type": "object",
+        "properties": {
+            "filter": {
+                "type": "object", "properties": {
+                    "_id": {
+                        "type": "string"
+                    }
+                }, "required": ["_id"]
+            }
+        },
+        "required": ["filter"],
+    }
+
+    _model = model_from_mcp_schema("test_nested_underscore_property", schema)
+
+    instance = _model.model_validate({"filter": {"_id": "doc-1"}})
+    assert instance.filter.id_ == "doc-1"
+    assert instance.model_dump(by_alias=True) == {"filter": {"_id": "doc-1"}}
+
+
+def test_ordinary_property_names_get_no_alias():
+    schema = {"type": "object", "properties": {"id": {"type": "string"}, "model_name": {"type": "string"}}}
+
+    _model = model_from_mcp_schema("test_ordinary_property_names", schema)
+
+    assert {name: field.alias for name, field in _model.model_fields.items()} == {"id": None, "model_name": None}
+    assert "validate_by_name" not in _model.model_config