diff --git a/.github/images/demo.gif b/.github/images/demo.gif
new file mode 100644
index 0000000..51a4c6a
Binary files /dev/null and b/.github/images/demo.gif differ
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..78234d2
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,50 @@
+# Contributing to NetContextServer
+
+## Quick Start
+
+1. Fork and clone the repository
+2. Install .NET 9.0 SDK or later
+3. Build: `dotnet build`
+4. Test: `dotnet test`
+
+## Development Process
+
+1. Create a feature branch:
+   ```bash
+   git checkout -b feature/your-feature
+   # or
+   git checkout -b fix/your-bug
+   ```
+
+2. Make changes:
+   - Follow C# coding conventions
+   - Add/update tests
+   - Update relevant documentation
+
+3. Commit with clear messages:
+   ```bash
+   git commit -m "feat: add new feature
+
+   - Brief description of changes
+   - Additional details if needed
+
+   Fixes #123"
+   ```
+
+4. Push and create a Pull Request
+
+## Guidelines
+
+- Keep changes focused and atomic
+- Include tests for new features
+- Update documentation as needed
+- Follow existing code style
+- Test AI integration if relevant
+
+## Need Help?
+
+- Check existing issues
+- Create a new issue
+- Join community discussions
+
+Thank you for contributing! 
\ No newline at end of file
diff --git a/NetContextServer.sln b/NetContextServer.sln
index 7625944..676e53b 100644
--- a/NetContextServer.sln
+++ b/NetContextServer.sln
@@ -5,7 +5,10 @@ VisualStudioVersion = 17.13.35818.85
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "docs", "docs", "{02EA681E-C7D8-13C7-8484-4AC65E1B71E8}"
 	ProjectSection(SolutionItems) = preProject
-		README.md = README.md
+		docs\configuration.md = docs\configuration.md
+		docs\getting-started.md = docs\getting-started.md
+		docs\integrations.md = docs\integrations.md
+		docs\tool-reference.md = docs\tool-reference.md
 	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{827E0CD3-B72D-47B6-A68D-7590B98EB39B}"
@@ -21,6 +24,8 @@ EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{8EC462FD-D22E-90A8-E5CE-7E832BA40C5D}"
 	ProjectSection(SolutionItems) = preProject
 		.github\workflows\ci.yaml = .github\workflows\ci.yaml
+		CONTRIBUTING.md = CONTRIBUTING.md
+		README.md = README.md
 	EndProjectSection
 EndProject
 Global
diff --git a/README.md b/README.md
index 5b5e139..cd156b2 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,85 @@
 # NetContextServer
 
-A .NET Codebase Context MCP Server that provides AI assistants with access to your .NET codebase through the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction). This allows AI tools to understand and work with your specific codebase context.
+<div align="center">
+
+🔍 **Supercharge Your AI Coding Assistant with Deep .NET Codebase Understanding**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Built with .NET](https://img.shields.io/badge/Built%20with-.NET-512BD4)](https://dotnet.microsoft.com/)
+[![MCP Compatible](https://img.shields.io/badge/MCP-Compatible-brightgreen)](https://modelcontextprotocol.io/)
+
+</div>
+
+NetContextServer empowers AI coding assistants like Cursor AI to deeply understand your .NET codebase through the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction). This means more accurate code suggestions, better answers to your questions, and a more productive coding experience.
+
+![Demo of NetContextServer with Cursor AI](.github/images/demo.gif)
+
+## ✨ Key Features
+
+- 🧠 **Semantic Code Search**: Find code by describing what you're looking for in natural language
+- 🔍 **Intelligent Navigation**: Help AI tools understand your project structure and dependencies
+- 🛡️ **Built-in Security**: Safe file access with automatic protection of sensitive data
+- 🚀 **Cursor AI Integration**: Seamless setup with Cursor AI for enhanced coding assistance
+- 📦 **Package Analysis**: Understand your dependencies and get update recommendations
+- ⚡ **Fast & Efficient**: Quick indexing and response times for large codebases
+
+## 🚀 Quick Start
+
+1. **Clone & Build**:
+```bash
+git clone https://github.com/willibrandon/NetContextServer.git
+cd NetContextServer
+dotnet build
+```
+
+2. **Set Up** (optional, for semantic search):
+```bash
+# Set Azure OpenAI credentials in environment:
+AZURE_OPENAI_ENDPOINT=your_endpoint
+AZURE_OPENAI_API_KEY=your_key
+```
+
+3. **Start Using**:
+```bash
+# Point to your project
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- set-base-dir --directory "path/to/your/project"
+
+# Try semantic search
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- semantic-search --query "find authentication logic"
+```
+
+👉 **[Read our Getting Started Guide](docs/getting-started.md)** for detailed setup instructions and best practices.
+
+## 🔌 Integration with Cursor AI
+
+1. Open Cursor AI
+2. Press `Cmd/Ctrl + Shift + P`
+3. Type "Configure MCP Server"
+4. Enter:
+```json
+{
+  "command": "dotnet",
+  "args": ["run", "--project", "path/to/NetContextServer/src/NetContextServer/NetContextServer.csproj"]
+}
+```
+
+Now Cursor AI can understand your codebase! Try asking it questions like:
+- "List all .NET source files in this project directory"
+- "Search for exact text matches in the code files"
+- "Analyze NuGet packages in all projects"
+- "Get the current list of ignore patterns"
+- "Add these ignore patterns: *.generated.cs, bin/*"
+- "List all .csproj files in this directory"
+- "Show me the contents of this file"
+- "What's the current base directory for file operations?"
+
+## 📚 Documentation
+
+- [Getting Started Guide](docs/getting-started.md) - Quick setup and first steps
+- [Tool Reference](docs/tool-reference.md) - Detailed tool documentation
+- [Configuration Guide](docs/configuration.md) - Advanced configuration options
+- [Integration Examples](docs/integrations.md) - Using with different AI tools
+- [Contributing Guide](CONTRIBUTING.md) - How to help improve NetContextServer
 
 ## Features
 
diff --git a/docs/configuration.md b/docs/configuration.md
new file mode 100644
index 0000000..45429f8
--- /dev/null
+++ b/docs/configuration.md
@@ -0,0 +1,210 @@
+# Advanced Configuration Guide
+
+This guide covers advanced configuration options for NetContextServer to help you customize and optimize its behavior for your specific needs.
+
+## Environment Variables
+
+### Azure OpenAI Configuration
+Required for semantic search functionality:
+```bash
+# Azure OpenAI Settings
+AZURE_OPENAI_ENDPOINT=your_azure_openai_endpoint
+AZURE_OPENAI_API_KEY=your_azure_openai_key
+```
+
+## Base Directory Configuration
+
+The base directory is a critical security feature that defines the root of your workspace. All file operations are restricted to this directory and its subdirectories.
+
+### Setting the Base Directory
+
+You can set the base directory in several ways:
+
+1. **Command Line**:
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- set-base-dir --directory "D:\YourProject"
+```
+
+2. **Environment Variable** (optional):
+```bash
+NETCONTEXT_BASE_DIR=D:\YourProject
+```
+
+### Base Directory Best Practices
+
+1. Set to your solution or project root
+2. Ensure it contains all necessary source files
+3. Avoid setting to system directories or root paths
+4. Use absolute paths for reliability
+
+## Security Configuration
+
+### Ignore Patterns
+
+NetContextServer uses ignore patterns to protect sensitive files and optimize performance.
+
+#### Default Ignore Patterns
+These patterns are always active and cannot be disabled:
+```
+*.env
+appsettings.*.json
+*.pfx
+*.key
+*.pem
+*password*
+*secret*
+```
+
+#### Custom Ignore Patterns
+Add your own patterns for project-specific needs:
+```bash
+# Add patterns
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- add-ignore-patterns --patterns "*.generated.cs" "bin/*" "obj/*"
+
+# View current patterns
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- get-ignore-patterns
+```
+
+#### Persistent Ignore Patterns
+Patterns are stored in `ignore_patterns.json`. Location can be found using:
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- get-state-file-location
+```
+
+### File Access Controls
+
+1. **Size Limits**
+   - Large files are truncated to prevent memory issues
+   - Default limit: 1MB per file
+   - Binary files are blocked
+
+2. **Path Validation**
+   - All file paths must be within base directory
+   - Symbolic links are resolved and validated
+   - Parent directory traversal (`..`) is blocked
+
+## Search Configuration
+
+### Text Search
+
+Text search is configured for:
+- Case-sensitive matching
+- Regular expression support
+- Line number reporting
+- Context lines around matches
+
+### Semantic Search
+
+Semantic search can be customized with:
+
+1. **Results Count**
+```bash
+# Customize number of results
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- semantic-search --query "error handling" --top 10
+```
+
+2. **Index Management**
+- Files are automatically indexed on first search
+- Index is maintained in memory for performance
+- Reindexing occurs when files change
+
+## Performance Optimization
+
+### File Scanning
+
+1. **Excluded Directories**
+   - `bin` and `obj` directories are skipped by default
+   - Add custom directories to ignore for faster scanning
+
+2. **File Type Filtering**
+   - Focus on relevant file types
+   - Add ignore patterns for non-code files
+
+### Memory Management
+
+1. **File Content Caching**
+   - Recently accessed files are cached
+   - Large files are read in chunks
+
+2. **Search Index**
+   - Semantic search index is optimized for speed
+   - Index is updated incrementally
+
+## Integration Configuration
+
+### Cursor AI Setup
+
+1. **MCP Server Configuration**
+```json
+{
+  "command": "dotnet",
+  "args": ["run", "--project", "path/to/NetContextServer/src/NetContextServer/NetContextServer.csproj"]
+}
+```
+
+2. **Recommended Settings**
+   - Keep server running for better performance
+   - Configure in workspace settings for project-specific setup
+
+### CursorMCPMonitor Integration
+
+For debugging MCP communication:
+1. Install CursorMCPMonitor
+2. Configure logging level
+3. Monitor real-time interactions
+
+## Logging and Diagnostics
+
+### Log Levels
+Available log levels:
+- ERROR: Critical issues
+- WARN: Important warnings
+- INFO: General operation info
+- DEBUG: Detailed debugging info
+
+### Diagnostic Information
+- Server status
+- Connection details
+- Operation timing
+- Error traces
+
+## Best Practices
+
+1. **Project Structure**
+   - Set base directory at solution root
+   - Use consistent file organization
+   - Follow standard .NET project layout
+
+2. **Security**
+   - Review ignore patterns regularly
+   - Keep sensitive files outside source tree
+   - Use environment variables for secrets
+
+3. **Performance**
+   - Optimize ignore patterns
+   - Clean up unused files
+   - Monitor memory usage
+
+4. **Integration**
+   - Test configuration changes
+   - Verify file access patterns
+   - Monitor error logs
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Access Denied**
+   - Verify base directory setting
+   - Check file permissions
+   - Review ignore patterns
+
+2. **Search Not Working**
+   - Verify Azure OpenAI credentials
+   - Check file indexing status
+   - Review search patterns
+
+3. **Performance Issues**
+   - Optimize ignore patterns
+   - Clean up temporary files
+   - Review large file handling
diff --git a/docs/getting-started.md b/docs/getting-started.md
new file mode 100644
index 0000000..977418e
--- /dev/null
+++ b/docs/getting-started.md
@@ -0,0 +1,153 @@
+# Getting Started with NetContextServer
+
+Welcome to NetContextServer! This guide will help you get up and running in just a few minutes. NetContextServer is a powerful tool that enhances AI coding assistants by giving them deep understanding of your .NET codebase.
+
+## Why NetContextServer?
+
+When you're using AI coding assistants like Cursor AI or Claude, they work best when they understand your codebase. NetContextServer bridges this gap by:
+- 🔍 Enabling AI to search and understand your code semantically
+- 📁 Providing secure access to your project structure and files
+- 🛡️ Maintaining security with built-in safeguards for sensitive data
+- 🚀 Making AI suggestions more relevant to your specific project
+
+## Quick Start (5 Minutes)
+
+### Prerequisites
+- .NET 8.0 or later
+- For semantic search: Azure OpenAI account (optional but recommended)
+- Git
+
+### 1. Install NetContextServer
+
+```bash
+# Clone the repository
+git clone https://github.com/willibrandon/NetContextServer.git
+cd NetContextServer
+
+# Build the solution
+dotnet build
+```
+
+### 2. Set Up Environment (for Semantic Search)
+
+Create a `.env` file in the root directory:
+```env
+AZURE_OPENAI_ENDPOINT=your_azure_openai_endpoint
+AZURE_OPENAI_API_KEY=your_azure_openai_key
+```
+
+> 💡 **Note**: NetContextServer works without Azure OpenAI, but semantic search will be disabled.
+
+### 3. Test the Installation
+
+```bash
+# Run a simple hello test
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- hello
+
+# Set your project directory
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- set-base-dir --directory "path/to/your/project"
+
+# Try a semantic search
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- semantic-search --query "find authentication logic"
+```
+
+## Integration with Cursor AI
+
+Cursor AI is one of the primary ways to use NetContextServer. Here's how to set it up:
+
+1. Open Cursor AI
+2. Press `Cmd/Ctrl + Shift + P` to open the command palette
+3. Type "Configure MCP Server" and select it
+4. Enter the following configuration:
+   ```json
+   {
+     "command": "dotnet",
+     "args": ["run", "--project", "path/to/NetContextServer/src/NetContextServer/NetContextServer.csproj"]
+   }
+   ```
+5. Start coding! Try asking Cursor AI questions about your codebase.
+
+Example prompts to try:
+- "Find all authentication-related code in the project"
+- "Show me how error handling is implemented"
+- "List all API endpoints in the codebase"
+
+## Common Operations
+
+### Project Navigation
+```bash
+# List all projects in a directory
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- list-projects-in-dir --directory "path/to/dir"
+
+# List source files in a project
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- list-source-files --project-dir "path/to/project"
+```
+
+### Code Search
+```bash
+# Text-based search
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- search-code --text "authentication"
+
+# Semantic search (requires Azure OpenAI)
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- semantic-search --query "how is user data validated"
+```
+
+### Security Management
+```bash
+# Add files to ignore
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- add-ignore-patterns --patterns "*.secret" "*.key"
+
+# View current ignore patterns
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- get-ignore-patterns
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **"Directory not found" error**
+   - Ensure the path exists and is accessible
+   - Use absolute paths if relative paths aren't working
+
+2. **Semantic search not working**
+   - Check your Azure OpenAI environment variables
+   - Verify your Azure OpenAI service is running
+   - Ensure you have embedding model access
+
+3. **Access denied errors**
+   - Verify the file/directory is within your set base directory
+   - Check file permissions
+   - Review ignore patterns that might be blocking access
+
+### Getting Help
+
+- Check the [GitHub Issues](https://github.com/willibrandon/NetContextServer/issues) for known problems
+- Use [CursorMCPMonitor](https://github.com/willibrandon/CursorMCPMonitor) to debug MCP communication
+- Create a new issue if you find a bug or have a feature request
+
+## Next Steps
+
+- Explore the [full command reference](./command-reference.md)
+- Learn about [advanced configuration options](./configuration.md)
+- See [integration examples](./integrations.md) with other AI tools
+- Check out our [contribution guidelines](../CONTRIBUTING.md) if you want to help improve NetContextServer
+
+## Tips for Best Results
+
+1. **Set a Specific Base Directory**
+   - Always set the base directory to your project root
+   - This ensures AI tools have access to all relevant files
+
+2. **Use Semantic Search Effectively**
+   - Write natural language queries
+   - Be specific about what you're looking for
+   - Use domain terminology from your codebase
+
+3. **Manage Ignore Patterns**
+   - Add patterns for generated files to reduce noise
+   - Don't forget to ignore sensitive files
+   - Review patterns periodically
+
+4. **Keep the Server Running**
+   - Start NetContextServer before beginning your coding session
+   - It will maintain an index of your code for faster searches 
\ No newline at end of file
diff --git a/docs/integrations.md b/docs/integrations.md
new file mode 100644
index 0000000..9df521d
--- /dev/null
+++ b/docs/integrations.md
@@ -0,0 +1,97 @@
+# Integration Guide
+
+## Cursor AI Integration
+
+### Quick Setup
+1. Open Cursor AI
+2. Press `Cmd/Ctrl + Shift + P`
+3. Type "Configure MCP Server"
+4. Enter configuration:
+```json
+{
+  "command": "dotnet",
+  "args": ["run", "--project", "path/to/NetContextServer/src/NetContextServer/NetContextServer.csproj"]
+}
+```
+
+### Verification
+Test the integration directly in Cursor AI's chat interface by asking questions like:
+
+1. Basic file operations:
+   - "What's the current base directory?"
+   - "List all projects in this solution"
+   - "Show me the source files in this project"
+
+2. Search capabilities:
+   - "Search for files containing 'Program'"
+   - "Find code related to authentication"
+   - "Look for error handling implementations"
+
+3. Package analysis:
+   - "Analyze the NuGet packages in this project"
+   - "Show me all project dependencies"
+
+The AI assistant will use NetContextServer's capabilities to answer these questions directly in the chat.
+
+## MCP Protocol Support
+
+NetContextServer implements the [Model Context Protocol](https://modelcontextprotocol.io/introduction) for AI tool integration.
+
+### Supported Operations
+- File system navigation
+- Code search (text and semantic)
+- Project structure analysis
+- Package analysis
+- Pattern management
+
+### Security
+- All operations respect base directory restrictions
+- Sensitive file patterns are automatically ignored
+- File size limits are enforced
+
+## Debugging Integration
+
+### Using CursorMCPMonitor
+[CursorMCPMonitor](https://github.com/willibrandon/CursorMCPMonitor) provides real-time monitoring of MCP communications.
+
+1. Installation:
+```bash
+git clone https://github.com/willibrandon/CursorMCPMonitor.git
+cd CursorMCPMonitor
+dotnet build
+```
+
+2. Usage:
+```bash
+dotnet run --project CursorMCPMonitor.csproj
+```
+
+### Common Integration Issues
+
+1. **Connection Failed**
+   - Verify NetContextServer is running
+   - Check port availability
+   - Confirm path configuration
+
+2. **Permission Errors**
+   - Verify base directory setting
+   - Check file access permissions
+   - Review ignore patterns
+
+3. **Search Not Working**
+   - Confirm Azure OpenAI setup (if using semantic search)
+   - Verify file indexing status
+
+## Other AI Tools
+
+NetContextServer can integrate with any tool supporting the MCP protocol. Key requirements:
+
+1. **Tool Requirements**
+   - MCP protocol support
+   - .NET file system compatibility
+   - Base directory respect
+
+2. **Configuration Steps**
+   - Point tool to NetContextServer endpoint
+   - Configure authentication (if required)
+   - Set up base directory 
\ No newline at end of file
diff --git a/docs/tool-reference.md b/docs/tool-reference.md
new file mode 100644
index 0000000..bfdd3fd
--- /dev/null
+++ b/docs/tool-reference.md
@@ -0,0 +1,227 @@
+# NetContextServer Tool Reference
+
+This document provides detailed documentation for all available tools in NetContextServer. Each tool is documented with its description, parameters, and usage examples.
+
+## File Operations
+
+### `list_files`
+Lists all .NET source files in the specified project directory.
+
+**Parameters:**
+- `--project-path` (required): Absolute path to the project directory containing the .cs files
+
+**Example:**
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- list-files --project-path "D:\Projects\MyApp\src\MyProject"
+```
+
+### `list_projects`
+Scans the current solution and returns all .csproj files found.
+
+**Parameters:** None
+
+**Example:**
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- list-projects
+```
+
+### `list_projects_in_dir`
+Searches a specific directory for .csproj files.
+
+**Parameters:**
+- `--directory` (required): Absolute path to the directory to search for .csproj files
+
+**Example:**
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- list-projects-in-dir --directory "D:\Projects\MyApp\src"
+```
+
+### `list_solutions`
+Returns all .sln files found in the base directory.
+
+**Parameters:** None
+
+**Example:**
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- list-solutions
+```
+
+### `list_source_files`
+Lists all source files in a project directory.
+
+**Parameters:**
+- `--project-dir` (required): Absolute path to the project directory to scan for source files
+
+**Example:**
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- list-source-files --project-dir "D:\Projects\MyApp\src\MyProject"
+```
+
+### `open_file`
+Reads and returns the contents of a specified file.
+
+**Parameters:**
+- `--file-path` (required): Absolute path to the file to read
+
+**Example:**
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- open-file --file-path "D:\Projects\MyApp\src\MyProject\Program.cs"
+```
+
+### `set_base_directory`
+Sets the base directory for all file operations.
+
+**Parameters:**
+- `--directory` (required): Absolute path to set as the new base directory. Must be a valid, existing directory
+
+**Example:**
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- set-base-dir --directory "D:\Projects\MyApp"
+```
+
+### `get_base_directory`
+Returns the current base directory used for all file operations.
+
+**Parameters:** None
+
+**Example:**
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- get-base-dir
+```
+
+## Search Operations
+
+### `search_code`
+Performs a text-based search across all code files for the specified text.
+
+**Parameters:**
+- `--text` (required): The exact text string to search for in the codebase
+
+**Example:**
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- search-code --text "public class Program"
+```
+
+### `semantic_search`
+Performs a semantic similarity search across the codebase using AI.
+
+**Parameters:**
+- `--query` (required): Natural language description of the code you're looking for
+- `--top` (optional): Number of results to return (default: 5)
+
+**Example:**
+```bash
+# With default number of results
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- semantic-search --query "file handling operations"
+
+# With custom number of results
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- semantic-search --query "error handling" --top 10
+```
+
+**Note:** Requires Azure OpenAI credentials to be set in environment variables:
+- `AZURE_OPENAI_ENDPOINT`
+- `AZURE_OPENAI_API_KEY`
+
+## Package Analysis
+
+### `analyze_packages`
+Analyzes NuGet packages in all projects found in the base directory.
+
+**Parameters:** None
+
+**Example:**
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- analyze-packages
+```
+
+**Output includes:**
+- Package versions and available updates
+- Usage analysis
+- Recommendations for updates or removal
+
+## Ignore Pattern Management
+
+### `add_ignore_patterns`
+Adds new patterns to the ignore list for file scanning operations.
+
+**Parameters:**
+- `--patterns` (required): Array of glob patterns to ignore (e.g. '*.generated.cs', 'bin/*')
+
+**Example:**
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- add-ignore-patterns --patterns "*.generated.cs" "bin/*" "obj/*"
+```
+
+### `clear_ignore_patterns`
+Removes all user-defined ignore patterns from both memory and the persistent state file.
+
+**Parameters:** None
+
+**Example:**
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- clear-ignore-patterns
+```
+
+### `get_ignore_patterns`
+Retrieves the current list of active ignore patterns from memory.
+
+**Parameters:** None
+
+**Example:**
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- get-ignore-patterns
+```
+
+### `get_state_file_location`
+Returns the absolute path to the ignore_patterns.json state file.
+
+**Parameters:** None
+
+**Example:**
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- get-state-file-location
+```
+
+### `remove_ignore_patterns`
+Removes specific patterns from the ignore list.
+
+**Parameters:**
+- `--patterns` (required): Array of glob patterns to remove from the ignore list
+
+**Example:**
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- remove-ignore-patterns --patterns "*.generated.cs" "bin/*"
+```
+
+## General Tools
+
+### `hello`
+Simple health check endpoint that returns a greeting message.
+
+**Parameters:** None
+
+**Example:**
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- hello
+```
+
+## Default Ignore Patterns
+
+The following patterns are ignored by default to protect sensitive information:
+- `*.env` - Environment files
+- `appsettings.*.json` - Application settings
+- `*.pfx` - Certificate files
+- `*.key` - Key files
+- `*.pem` - PEM files
+- `*password*` - Files containing "password" in the name
+- `*secret*` - Files containing "secret" in the name
+
+## Error Handling
+
+The server provides clear error messages for common scenarios:
+- Directory not found
+- Access denied (outside base directory)
+- Invalid patterns
+- File size limits exceeded
+- Restricted file types
+- Missing environment variables for semantic search 
\ No newline at end of file