Update documentation to use model-level indexing syntax

- Update models.md and README.md examples to use index=True on model class
- Add section explaining field exclusion with Field(index=False)
- Document migration from field-level to model-level indexing
- Remove redundant index=True from individual fields in examples
- Add comprehensive explanation of new indexing approach

Author: abrookins

README.md

@@ -216,7 +216,7 @@ Next, we'll show you the **rich query expressions** and **embedded models** Redi
 
 Redis OM comes with a rich query language that allows you to query Redis with Python expressions.
 
-To show how this works, we'll make a small change to the `Customer` model we defined earlier. We'll add `Field(index=True)` to tell Redis OM that we want to index the `last_name` and `age` fields:
+To show how this works, we'll make a small change to the `Customer` model we defined earlier. We'll add `index=True` to the model class to tell Redis OM that we want to index all fields in the model:
 
 ```python
 import datetime
@@ -225,18 +225,17 @@ from typing import Optional
 from pydantic import EmailStr
 
 from redis_om import (
-    Field,
     HashModel,
     Migrator
 )
 
 
-class Customer(HashModel):
+class Customer(HashModel, index=True):
     first_name: str
-    last_name: str = Field(index=True)
+    last_name: str
     email: EmailStr
     join_date: datetime.date
-    age: int = Field(index=True)
+    age: int
     bio: Optional[str] = None
 
 
@@ -294,14 +293,13 @@ class Address(EmbeddedJsonModel):
     postal_code: str = Field(index=True)
 
 
-class Customer(JsonModel):
-    first_name: str = Field(index=True)
-    last_name: str = Field(index=True)
-    email: str = Field(index=True)
+class Customer(JsonModel, index=True):
+    first_name: str
+    last_name: str
+    email: str
     join_date: datetime.date
-    age: int = Field(index=True)
-    bio: Optional[str] = Field(index=True, full_text_search=True,
-                               default="")
+    age: int
+    bio: Optional[str] = Field(full_text_search=True, default="")
 
     # Creates an embedded model.
     address: Address
@@ -392,9 +390,9 @@ credential_provider = create_from_default_azure_credential(
 
 db = Redis(host="cluster-name.region.redis.azure.net", port=10000, ssl=True, ssl_cert_reqs=None, credential_provider=credential_provider)
 db.flushdb()
-class User(HashModel):
+class User(HashModel, index=True):
     first_name: str
-    last_name: str = Field(index=True)
+    last_name: str
 
     class Meta:
         database = db

docs/models.md

@@ -124,7 +124,7 @@ Here is a table of the settings available in the Meta object and what they contr
 | primary_key_pattern     | A format string producing the base string for a Redis key representing this model. This string should accept a "pk" format argument. **Note:** This is a "new style" format string, which will be called with `.format()`.                                  | "{pk}"                                                           |
 | database                | A redis.asyncio.Redis or redis.Redis client instance that the model will use to communicate with Redis.                                                                                                                                                         | A new instance created with connections.get_redis_connection(). |
 | primary_key_creator_cls | A class that adheres to the PrimaryKeyCreator protocol, which Redis OM will use to create a primary key for a new model instance.                                                                                                                           | UlidPrimaryKey                                                  |
-| index_name              | The RediSearch index name to use for this model. Only used if at least one of the model's fields are marked as indexable (`index=True`).                                                                                                                    | "{global_key_prefix}:{model_key_prefix}:index"                  |
+| index_name              | The RediSearch index name to use for this model. Only used if the model is indexed (`index=True` on the model class).                                                                                                                    | "{global_key_prefix}:{model_key_prefix}:index"                  |
 | embedded                | Whether or not this model is "embedded." Embedded models are not included in migrations that create and destroy indexes. Instead, their indexed fields are included in the index for the parent model. **Note**: Only `JsonModel` can have embedded models. | False                                                           |
 | encoding                | The default encoding to use for strings. This encoding is given to redis-py at the connection level. In both cases, Redis OM will decode binary strings from Redis using your chosen encoding.                                                  | "utf-8"                                                         |
 ## Configuring Pydantic
@@ -230,25 +230,77 @@ print(andrew.bio)  # <- So we got the default value.
 
 The model will then save this default value to Redis the next time you call `save()`.
 
-## Marking a Field as Indexed
+## Model-Level Indexing
 
-If you're using the RediSearch module in your Redis instance, you can mark a field as "indexed." As soon as you mark any field in a model as indexed, Redis OM will automatically create and manage an secondary index for the model for you, allowing you to query on any indexed field.
+If you're using the RediSearch module in your Redis instance, you can make your entire model indexed by adding `index=True` to the model class declaration. This automatically creates and manages a secondary index for the model, allowing you to query on any field.
 
-To mark a field as indexed, you need to use the Redis OM `Field()` helper, like this:
+To make a model indexed, add `index=True` to your model class:
 
 ```python
-from redis_om import (
-    Field,
-    HashModel,
-)
+from redis_om import HashModel
 
 
-class Customer(HashModel):
+class Customer(HashModel, index=True):
     first_name: str
+    last_name: str
+    email: str
+    age: int
+```
+
+In this example, all fields in the `Customer` model will be indexed automatically.
+
+### Excluding Fields from Indexing
+
+By default, all fields in an indexed model are indexed. You can exclude specific fields from indexing using `Field(index=False)`:
+
+```python
+from redis_om import HashModel, Field
+
+
+class Customer(HashModel, index=True):
+    first_name: str = Field(index=False)  # Not indexed
+    last_name: str                        # Indexed (default)
+    email: str                           # Indexed (default)
+    age: int                             # Indexed (default)
+```
+
+### Field-Specific Index Options
+
+While you no longer need to specify `index=True` on individual fields (since the model is indexed), you can still use field-specific options to control indexing behavior:
+
+```python
+from redis_om import HashModel, Field
+
+
+class Customer(HashModel, index=True):
+    first_name: str = Field(index=False)           # Excluded from index
+    last_name: str                                 # Indexed as TAG (default)
+    bio: str = Field(full_text_search=True)        # Indexed as TEXT for full-text search
+    age: int = Field(sortable=True)                # Indexed as NUMERIC, sortable
+    category: str = Field(case_sensitive=False)    # Indexed as TAG, case-insensitive
+```
+
+### Migration from Field-Level Indexing
+
+**Redis OM 1.0+ uses model-level indexing.** If you're upgrading from an earlier version, you'll need to update your models:
+
+```python
+# Old way (0.x) - field-by-field indexing
+class Customer(HashModel):
+    first_name: str = Field(index=True)
     last_name: str = Field(index=True)
+    email: str = Field(index=True)
+    age: int = Field(index=True, sortable=True)
+
+# New way (1.0+) - model-level indexing
+class Customer(HashModel, index=True):
+    first_name: str
+    last_name: str
+    email: str
+    age: int = Field(sortable=True)
 ```
 
-In this example, we marked `Customer.last_name` as indexed.
+For detailed migration instructions, see the [0.x to 1.0 Migration Guide](migration_guide_0x_to_1x.md).
 
 ### Field Index Types
 
@@ -265,17 +317,17 @@ Redis OM automatically chooses the appropriate RediSearch field type based on th
 By default, string fields are indexed as TAG fields, which only support exact matching and cannot be sorted. To make a string field sortable, you must create a TEXT field by adding `full_text_search=True`:
 
 ```python
-class Customer(HashModel):
+class Customer(HashModel, index=True):
     # TAG field - exact matching only, cannot be sorted
-    category: str = Field(index=True)
-    
+    category: str
+
     # TEXT field - supports full-text search and sorting
-    name: str = Field(index=True, sortable=True, full_text_search=True)
+    name: str = Field(sortable=True, full_text_search=True)
 ```
 
 Only NUMERIC, TEXT, and GEO field types support sorting in RediSearch.
 
-To create the indexes for any models that have indexed fields, use the `migrate` CLI command that Redis OM installs in your Python environment.
+To create the indexes for any models that are indexed (have `index=True`), use the `om migrate` CLI command that Redis OM installs in your Python environment.
 
 This command detects any `JsonModel` or `HashModel` instances in your project and does the following for each model that isn't abstract or embedded:
 
@@ -311,11 +363,11 @@ The `.values()` method returns query results as dictionaries instead of model in
 ```python
 from redis_om import HashModel, Field
 
-class Customer(HashModel):
-    first_name: str = Field(index=True)
-    last_name: str = Field(index=True)
-    email: str = Field(index=True)
-    age: int = Field(index=True)
+class Customer(HashModel, index=True):
+    first_name: str
+    last_name: str
+    email: str
+    age: int
     bio: str
 
 # Get all fields as dictionaries
@@ -354,11 +406,11 @@ Both methods use Redis's `RETURN` clause for efficient field projection at the d
 Redis OM automatically converts field values to their proper Python types based on your model field definitions:
 
 ```python
-class Product(HashModel):
-    name: str = Field(index=True)
-    price: float = Field(index=True)
-    in_stock: bool = Field(index=True)
-    created_at: datetime.datetime = Field(index=True)
+class Product(HashModel, index=True):
+    name: str
+    price: float
+    in_stock: bool
+    created_at: datetime.datetime
 
 # Values are automatically converted to correct types
 products = Product.find().values("name", "price", "in_stock")
@@ -397,15 +449,15 @@ from redis_om import JsonModel, Field
 class Address(JsonModel):
     street: str
     city: str
-    zipcode: str = Field(index=True)
+    zipcode: str = Field(index=True)  # Specific field indexing for embedded model
     country: str = "USA"
-    
+
     class Meta:
         embedded = True
 
 class Customer(JsonModel, index=True):
-    name: str = Field(index=True)
-    age: int = Field(index=True)
+    name: str
+    age: int
     address: Address
     metadata: dict = Field(default_factory=dict)
 
@@ -525,11 +577,11 @@ For `JsonModel`, complex field types (embedded models, dictionaries, lists) cann
 
 ```python
 # ✓ Supported for efficient projection (all model types)
-class Product(HashModel):  # or JsonModel
-    name: str = Field(index=True)        # ✓ String fields
-    price: float = Field(index=True)     # ✓ Numeric fields  
-    active: bool = Field(index=True)     # ✓ Boolean fields
-    created: datetime = Field(index=True) # ✓ DateTime fields
+class Product(HashModel, index=True):  # or JsonModel
+    name: str        # ✓ String fields
+    price: float     # ✓ Numeric fields
+    active: bool     # ✓ Boolean fields
+    created: datetime # ✓ DateTime fields
 
 # JsonModel: These use fallback strategy (still supported)
 class Customer(JsonModel):