update docs

Author: shahar4499

CONTRIBUTING.md

@@ -2,46 +2,58 @@
 
 First off, thank you for considering contributing to FastAPI-MCP! 
 
-## Development Process
-
-1. Fork the repository
-2. Create a feature branch (`git checkout -b feature/amazing-feature`)
-3. Make your changes
-4. Run the tests (`pytest`)
-5. Format your code (`black .` and `isort .`)
-6. Commit your changes (`git commit -m 'Add some amazing feature'`)
-7. Push to the branch (`git push origin feature/amazing-feature`)
-8. Open a Pull Request
+## Development Setup
 
-## Setting Up Development Environment
+1. Make sure you have Python 3.10+ installed
+2. Install [uv](https://docs.astral.sh/uv/getting-started/installation/) (recommended) or pip
+3. Fork the repository
+4. Clone your fork and set up the development environment:
 
 ```bash
 # Clone your fork
-git clone https://github.com/tadata-org/fastapi_mcp
+git clone https://github.com/YOUR-USERNAME/fastapi_mcp.git
 cd fastapi-mcp
 
-# Create a virtual environment
-python -m venv venv
-source venv/bin/activate  # On Windows: venv\Scripts\activate
+# Create a virtual environment with uv (recommended)
+uv venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
 
-# Install development dependencies
-pip install -e ".[dev]"
+# Install development dependencies with uv
+uv add -e ".[dev]"
+
+# Alternatively, using pip
+# python -m venv venv
+# source venv/bin/activate  # On Windows: venv\Scripts\activate
+# pip install -e ".[dev]"
 ```
 
+## Development Process
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Make your changes
+4. Run type checking (`uv run mypy .`)
+5. Run the tests (`uv run pytest`)
+6. Format your code (`uv run ruff check .` and `uv run ruff format .`)
+7. Commit your changes (`git commit -m 'Add some amazing feature'`)
+8. Push to the branch (`git push origin feature/amazing-feature`)
+9. Open a Pull Request
+
 ## Code Style
 
 We use the following tools to ensure code quality:
 
-- **Black** for code formatting
-- **isort** for import sorting
 - **ruff** for linting
 - **mypy** for type checking
 
 Please make sure your code passes all checks before submitting a pull request:
 
 ```bash
-black .
-isort .
+# Using uv
+uv run ruff check .
+uv run mypy .
+
+# Or directly if tools are installed
 ruff check .
 mypy .
 ```
@@ -51,9 +63,23 @@ mypy .
 We use pytest for testing. Please write tests for any new features and ensure all tests pass:
 
 ```bash
+# Using uv
+uv run pytest
+
+# Or directly
 pytest
 ```
 
+## Project Architecture
+
+FastAPI-MCP uses a direct integration approach to add MCP functionality to FastAPI applications:
+
+1. The `server.py` module handles creating and mounting MCP servers to FastAPI apps
+2. The `http_tools.py` module converts FastAPI endpoints to MCP tools
+3. All integration happens at runtime - there is no code generation involved
+
+When contributing, please keep this architecture in mind and ensure your changes maintain the seamless integration experience.
+
 ## Pull Request Process
 
 1. Ensure your code follows the style guidelines of the project

INSTALL.md

@@ -16,85 +16,72 @@ A zero-configuration tool for integrating Model Context Protocol (MCP) servers w
 
 ## Installation
 
-You can install FastAPI-MCP directly from [PyPI](https://pypi.org/project/fastapi-mcp/):
+We recommend using [uv](https://docs.astral.sh/uv/), a fast Python package installer:
+
+```bash
+uv add fastapi-mcp
+```
+
+Alternatively, you can install with pip:
 
 ```bash
 pip install fastapi-mcp
 ```
 
 For detailed installation instructions and alternative methods, see [INSTALL.md](INSTALL.md).
 
-## Usage
-
-### Direct integration (Recommended)
+## Basic Usage
 
 The simplest way to use FastAPI-MCP is to add an MCP server directly to your FastAPI application:
 
 ```python
 from fastapi import FastAPI
 from fastapi_mcp import add_mcp_server
 
-# Create your FastAPI app
+# Your FastAPI app
 app = FastAPI()
 
-# Define your endpoints...
-@app.get("/items/{item_id}")
-def read_item(item_id: int, q: str = None):
-    """Get details for a specific item"""
-    return {"item_id": item_id, "q": q}
-
-# Add an MCP server to your app
-mcp_server = add_mcp_server(
+# Mount the MCP server to your app
+add_mcp_server(
     app,                    # Your FastAPI app
     mount_path="/mcp",      # Where to mount the MCP server
     name="My API MCP",      # Name for the MCP server
-    base_url="http://localhost:8000"  # Base URL for API requests
 )
-
-# Optionally add custom MCP tools
-@mcp_server.tool()
-async def get_item_count() -> int:
-    """Get the total number of items in the database."""
-    return 42  # Your custom implementation
 ```
 
-Your FastAPI app will now have an MCP server mounted at the specified path, with all your API endpoints available as MCP tools.
+That's it! Your auto-generated MCP server is now available at `https://app.base.url/mcp`.
 
-### Legacy CLI Usage
+## Advanced Usage
 
-The CLI is still available for backward compatibility:
+FastAPI-MCP provides several ways to customize and control how your MCP server is created and configured. Here are some advanced usage patterns:
 
-```bash
-# Generate an MCP server from a FastAPI app
-fastapi-mcp generate app.py
+```python
+from fastapi import FastAPI
+from fastapi_mcp import add_mcp_server
 
-# Preview the generated server
-fastapi-mcp preview
+app = FastAPI()
 
-# Run the generated server
-fastapi-mcp run
+mcp_server = add_mcp_server(
+    app,                                    # Your FastAPI app
+    mount_path="/mcp",                      # Where to mount the MCP server
+    name="My API MCP",                      # Name for the MCP server
+    describe_all_responses=True,            # False by default. Include all possible response schemas in tool descriptions, instead of just the successful response.
+    describe_full_response_schema=True      # False by default. Include full JSON schema in tool descriptions, instead of just an LLM-friendly response example.
+)
 
-# Install the server for Claude
-fastapi-mcp install
+# Add custom tools in addition to existing APIs.
+@mcp_server.tool()
+async def get_server_time() -> str:
+    """Get the current server time."""
+    from datetime import datetime
+    return datetime.now().isoformat()
 ```
 
-## How It Works
-
-FastAPI-MCP:
-
-1. Takes your FastAPI application
-2. Creates an MCP server instance
-3. Mounts the MCP server to your FastAPI app
-4. Extracts endpoint information from your OpenAPI schema
-5. Creates MCP tools that make HTTP requests to your API endpoints
-6. Preserves documentation and type information
-7. Registers the tools with the MCP server
-
 ## Examples
 
 See the [examples](examples) directory for complete examples.
 
-### Simple direct integration example:
+### Simple integration example:
 
 ```python
 from fastapi import FastAPI
@@ -130,49 +117,30 @@ Once your FastAPI app with MCP integration is running, you can connect to it wit
 2. In Claude, use the URL of your MCP server endpoint (e.g., `http://localhost:8000/mcp`)
 3. Claude will discover all available tools and resources automatically
 
-## Advanced Configuration
-
-FastAPI-MCP provides several options for advanced configuration:
+## Development and Contributing
 
-```python
-mcp_server = add_mcp_server(
-    app,
-    mount_path="/mcp",
-    name="My Custom MCP Server",
-    description="Custom description for the MCP server",
-    capabilities={"streaming": True},  # Set MCP capabilities
-    serve_tools=True,  # Whether to serve API endpoints as MCP tools
-    base_url="https://api.example.com"  # Base URL for API requests
-)
-```
+If you're interested in contributing to FastAPI-MCP:
 
-You can also create and mount an MCP server separately:
-
-```python
-from fastapi_mcp import create_mcp_server, mount_mcp_server
-
-# Create an MCP server
-mcp_server = create_mcp_server(app, name="My MCP Server")
+```bash
+# Clone the repository
+git clone https://github.com/tadata-org/fastapi_mcp.git
+cd fastapi_mcp
 
-# Add custom tools
-@mcp_server.tool()
-async def custom_tool():
-    return "Custom tool result"
+# Create a virtual environment and install dependencies with uv
+uv venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+uv add -e ".[dev]"
 
-# Mount the MCP server to the FastAPI app
-mount_mcp_server(app, mcp_server, mount_path="/mcp")
+# Run tests
+uv run pytest
 ```
 
+For more details about contributing, see [CONTRIBUTING.md](CONTRIBUTING.md).
+
 ## Requirements
 
 - Python 3.10+
-- FastAPI 0.100.0+
-- Pydantic 2.0.0+
-- MCP 1.3.0+
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit a pull request. See [CONTRIBUTING.md](CONTRIBUTING.md) for more information.
+- uv
 
 ## License