Merge branch 'main' into feat/sampling-example/simba

Author: simba-git

README.md

@@ -154,7 +154,7 @@ app.run()
 Build a complete data layer with custom logic:
 
 ```python
-from enrichmcp import EnrichMCP, EnrichModel, Relationship, EnrichContext
+from enrichmcp import EnrichMCP, EnrichModel, Relationship
 from datetime import datetime
 from decimal import Decimal
 from pydantic import Field
@@ -254,10 +254,11 @@ async def calculate_lifetime_value(user_id: int) -> Decimal:
 
 # ML-powered field
 @User.churn_risk.resolver
-async def predict_churn_risk(user_id: int, context: EnrichContext) -> float:
+async def predict_churn_risk(user_id: int) -> float:
     """Run churn prediction model."""
+    ctx = app.get_context()
     features = await gather_user_features(user_id)
-    model = context.get("ml_models")["churn"]
+    model = ctx.get("ml_models")["churn"]
     return float(model.predict_proba(features)[0][1])
 
 app.run()
@@ -360,9 +361,10 @@ class UserProfile(EnrichModel):
     bio: str | None = Field(default=None, description="Short bio")
 
 @app.retrieve
-async def get_user_profile(user_id: int, context: EnrichContext) -> UserProfile:
+async def get_user_profile(user_id: int) -> UserProfile:
+    ctx = app.get_context()
     # Access context provided by MCP client
-    auth_user = context.get("authenticated_user_id")
+    auth_user = ctx.get("authenticated_user_id")
     if auth_user != user_id:
         raise PermissionError("Can only access your own profile")
     return await db.get_profile(user_id)
@@ -375,7 +377,8 @@ Reduce API overhead by storing results in a per-request, per-user, or global cac
 ```python
 
 @app.retrieve
-async def get_customer(cid: int, ctx: EnrichContext) -> Customer:
+async def get_customer(cid: int) -> Customer:
+    ctx = app.get_context()
     async def fetch() -> Customer:
         return await db.get_customer(cid)
 

docs/api/context.md

@@ -74,9 +74,10 @@ class MyContext(EnrichContext):
 
 # Use in resources
 @app.retrieve
-async def get_data(context: MyContext) -> dict:
+async def get_data() -> dict:
+    ctx = app.get_context()
     # Use your custom context
-    return await context.db.fetch_data()
+    return await ctx.db.fetch_data()
 ```
 
-Note: Full context support with dependency injection is planned for future releases.
+Note: Dependency injection is no longer supported; always call ``app.get_context()`` to access the current request context.

docs/api/parameter.md

@@ -2,8 +2,7 @@
 
 `EnrichParameter` attaches hints like descriptions and examples to function parameters.
 When a parameter's default value is an instance of `EnrichParameter`, those hints
-are appended to the generated tool description (except for parameters typed as
-`EnrichContext`).
+are appended to the generated tool description.
 
 ```python
 from enrichmcp import EnrichParameter

docs/concepts.md

@@ -195,8 +195,9 @@ class AppContext(EnrichContext):
 
 
 @app.retrieve
-async def get_customer(customer_id: int, context: AppContext) -> Customer:
+async def get_customer(customer_id: int) -> Customer:
     """Get customer using context."""
+    context = app.get_context()
     # Check cache first
     cached = await context.cache.get(f"customer:{customer_id}")
     if cached:
@@ -249,16 +250,16 @@ The `describe_model()` output will list these allowed values.
 
 ## Context and Lifespan Management
 
-EnrichMCP extends FastMCP's context system to provide automatic injection of logging, progress reporting, and shared resources:
+EnrichMCP extends FastMCP's context system to provide logging, progress reporting, and shared resources.
 
-### Context Injection
+### Accessing Context
 
-Any resource or resolver can receive context by adding a parameter typed as `EnrichContext`:
+Call ``app.get_context()`` inside resources or resolvers to work with the current request context:
 
 ```python
 @app.retrieve
-async def my_resource(param: str, ctx: EnrichContext) -> Result:
-    # Context is automatically injected
+async def my_resource(param: str) -> Result:
+    ctx = app.get_context()
     await ctx.info("Processing request")
     await ctx.report_progress(50, 100)
     return result
@@ -300,7 +301,8 @@ Access lifespan resources through the context:
 
 ```python
 @User.orders.resolver
-async def get_user_orders(user_id: int, ctx: EnrichContext) -> list[Order]:
+async def get_user_orders(user_id: int) -> list[Order]:
+    ctx = app.get_context()
     # Get database from lifespan context
     db = ctx.request_context.lifespan_context["db"]
 
@@ -327,7 +329,8 @@ from enrichmcp.errors import NotFoundError, ValidationError, AuthorizationError
 
 
 @app.retrieve
-async def get_order(order_id: int, context: AppContext) -> Order:
+async def get_order(order_id: int) -> Order:
+    context = app.get_context()
     order = await context.db.get_order(order_id)
 
     if not order:

docs/getting-started.md

@@ -153,11 +153,10 @@ if __name__ == "__main__":
 
 ## Using Context
 
-EnrichMCP provides automatic context injection for accessing logging, progress reporting, and lifespan resources:
+Access logging, progress reporting, and lifespan resources through the application context:
 
 ```python
 from contextlib import asynccontextmanager
-from enrichmcp import EnrichContext
 
 
 # Set up lifespan for database connection
@@ -176,7 +175,8 @@ app = EnrichMCP("My API", "Description", lifespan=lifespan)
 
 # Use context in resources and resolvers
 @app.retrieve
-async def get_user(user_id: int, ctx: EnrichContext) -> User:
+async def get_user(user_id: int) -> User:
+    ctx = app.get_context()
     # Logging
     await ctx.info(f"Fetching user {user_id}")
 
@@ -189,7 +189,7 @@ async def get_user(user_id: int, ctx: EnrichContext) -> User:
     return await db.get_user(user_id)
 ```
 
-Context is automatically injected when you add a parameter typed as `EnrichContext`.
+
 
 ## Parameter Hints
 

docs/pagination.md

@@ -210,8 +210,8 @@ async def get_user_orders(
     user_id: int,
     page: int = 1,
     page_size: int = 10,
-    ctx: EnrichContext
 ) -> PageResult[Order]:
+    ctx = app.get_context()
     """Get user orders with pagination."""
     db = ctx.request_context.lifespan_context["db"]
 

docs/server_side_llm.md

@@ -43,7 +43,8 @@ other resources.
 
 ```python
 @app.retrieve
-async def summarize(text: str, ctx: EnrichContext) -> str:
+async def summarize(text: str) -> str:
+    ctx = app.get_context()
     result = await ctx.ask_llm(
         f"Summarize this: {text}",
         model_preferences=prefer_fast_model(),

examples/caching/app.py

@@ -3,14 +3,15 @@
 import asyncio
 import random
 
-from enrichmcp import EnrichContext, EnrichMCP
+from enrichmcp import EnrichMCP
 
 app = EnrichMCP("Caching API", description="Demo of request caching")
 
 
 @app.retrieve
-async def slow_square(n: int, ctx: EnrichContext) -> int:
+async def slow_square(n: int) -> int:
     """Return n squared using request-scoped caching."""
+    ctx = app.get_context()
 
     async def compute() -> int:
         await asyncio.sleep(0.1)
@@ -20,8 +21,9 @@ async def compute() -> int:
 
 
 @app.retrieve
-async def fibonacci(n: int, ctx: EnrichContext) -> int:
+async def fibonacci(n: int) -> int:
     """Compute the n-th Fibonacci number with global caching."""
+    ctx = app.get_context()
 
     async def compute() -> int:
         await asyncio.sleep(0.1)
@@ -34,8 +36,9 @@ async def compute() -> int:
 
 
 @app.retrieve
-async def user_analytics(ctx: EnrichContext) -> dict:
+async def user_analytics() -> dict:
     """Return fake analytics for the user with user-scoped caching."""
+    ctx = app.get_context()
 
     async def compute() -> dict:
         await asyncio.sleep(0.1)

examples/server_side_llm_travel_planner/app.py

@@ -62,6 +62,7 @@ async def plan_trip(
     preferences: Annotated[str, Field(description="Your travel preferences")],
 ) -> list[Destination]:
     """Return three destinations that best match the given preferences."""
+    ctx = app.get_context()
 
     bullet_list = "\n".join(f"- {d.name}: {d.summary}" for d in DESTINATIONS)
     prompt = (

examples/shop_api_gateway/app.py

@@ -13,7 +13,7 @@
 import httpx
 from pydantic import Field
 
-from enrichmcp import EnrichContext, EnrichMCP, EnrichModel, Relationship
+from enrichmcp import EnrichMCP, EnrichModel, Relationship
 
 BACKEND_URL = "http://localhost:8001"
 
@@ -69,42 +69,43 @@ class Order(EnrichModel):
     products: list[Product] = Relationship(description="Products in the order")
 
 
-async def _client(ctx: EnrichContext) -> httpx.AsyncClient:
+async def _client() -> httpx.AsyncClient:
     """Helper to get the shared HTTP client."""
+    ctx = app.get_context()
     return ctx.request_context.lifespan_context["client"]
 
 
 @app.retrieve
-async def list_users(ctx: EnrichContext) -> list[User]:
+async def list_users() -> list[User]:
     """Fetch all users from the backend service."""
-    client = await _client(ctx)
+    client = await _client()
     resp = await client.get("/users")
     resp.raise_for_status()
     return [User(**u) for u in resp.json()]
 
 
 @app.retrieve
-async def get_user(user_id: int, ctx: EnrichContext) -> User:
+async def get_user(user_id: int) -> User:
     """Return a single user by ID."""
-    client = await _client(ctx)
+    client = await _client()
     resp = await client.get(f"/users/{user_id}")
     resp.raise_for_status()
     return User(**resp.json())
 
 
 @app.retrieve
-async def list_products(ctx: EnrichContext) -> list[Product]:
+async def list_products() -> list[Product]:
     """Retrieve all products available for sale."""
-    client = await _client(ctx)
+    client = await _client()
     resp = await client.get("/products")
     resp.raise_for_status()
     return [Product(**p) for p in resp.json()]
 
 
 @app.retrieve
-async def get_product(product_id: int, ctx: EnrichContext) -> Product:
+async def get_product(product_id: int) -> Product:
     """Get a single product by ID."""
-    client = await _client(ctx)
+    client = await _client()
     resp = await client.get(f"/products/{product_id}")
     resp.raise_for_status()
     return Product(**resp.json())
@@ -113,40 +114,37 @@ async def get_product(product_id: int, ctx: EnrichContext) -> Product:
 @app.retrieve
 async def list_orders(
     user_id: int | None = None,
-    ctx: EnrichContext | None = None,
 ) -> list[Order]:
     """List orders optionally filtered by user."""
-    if ctx is None:
-        raise RuntimeError("Context required")
-    client = await _client(ctx)
+    client = await _client()
     params = {"user_id": user_id} if user_id is not None else None
     resp = await client.get("/orders", params=params)
     resp.raise_for_status()
     return [Order(**o) for o in resp.json()]
 
 
 @app.retrieve
-async def get_order(order_id: int, ctx: EnrichContext) -> Order:
+async def get_order(order_id: int) -> Order:
     """Retrieve a specific order."""
-    client = await _client(ctx)
+    client = await _client()
     resp = await client.get(f"/orders/{order_id}")
     resp.raise_for_status()
     return Order(**resp.json())
 
 
 @User.orders.resolver
-async def get_orders_for_user(user_id: int, ctx: EnrichContext) -> list["Order"]:
-    return await list_orders(user_id=user_id, ctx=ctx)
+async def get_orders_for_user(user_id: int) -> list["Order"]:
+    return await list_orders(user_id=user_id)
 
 
 @Order.user.resolver
-async def get_order_user(user_id: int, ctx: EnrichContext) -> "User":
-    return await get_user(user_id=user_id, ctx=ctx)
+async def get_order_user(user_id: int) -> "User":
+    return await get_user(user_id=user_id)
 
 
 @Order.products.resolver
-async def get_order_products(order_id: int, ctx: EnrichContext) -> list[Product]:
-    client = await _client(ctx)
+async def get_order_products(order_id: int) -> list[Product]:
+    client = await _client()
     resp = await client.get(f"/orders/{order_id}")
     resp.raise_for_status()
     data = resp.json()