From 7192722fa77dfc535ecadf877f515522c9665d88 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 28 Jul 2025 18:52:02 +0000
Subject: [PATCH 1/6] Initial plan


From 45a102f34a9da8e329e6638f2328c14a9a6bd2ff Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 28 Jul 2025 19:05:28 +0000
Subject: [PATCH 2/6] Complete GitHub Pages documentation site with e-ink
 design

Co-authored-by: 0xrinegade <101195284+0xrinegade@users.noreply.github.com>
---
 .github/workflows/pages.yml       |   54 ++
 .gitignore                        |    8 +
 Gemfile                           |   22 +
 SITE_README.md                    |  227 ++++++
 _config.yml                       |  129 ++++
 _docs/API_REFERENCE.md            |  592 +++++++++++++++
 _docs/ARCHITECTURE.md             |  248 +++++++
 _docs/CONFIGURATION.md            |  537 ++++++++++++++
 _docs/DEPLOYMENT.md               |  535 ++++++++++++++
 _docs/EXAMPLES.md                 |  411 +++++++++++
 _docs/ONBOARDING.md               |  592 +++++++++++++++
 _docs/README.md                   |  230 ++++++
 _docs/benchmarks.md               |  157 ++++
 _docs/developer/error_handling.md |  156 ++++
 _docs/docker-scaling.md           |  385 ++++++++++
 _docs/mcp-json-rpc-api.md         |  238 ++++++
 _docs/metrics.md                  |  298 ++++++++
 _docs/security-audit.md           |   66 ++
 _docs/timeout-configuration.md    |  206 ++++++
 _docs/web-service.md              |  359 +++++++++
 _layouts/default.html             |  231 ++++++
 _layouts/docs.html                |    5 +
 _layouts/home.html                |    5 +
 assets/css/main.css               | 1136 +++++++++++++++++++++++++++++
 assets/images/favicon.svg         |   12 +
 assets/images/logo.svg            |   22 +
 assets/js/main.js                 |  566 ++++++++++++++
 bookmarks.md                      |  341 +++++++++
 index.md                          |  258 +++++++
 search.md                         |  361 +++++++++
 30 files changed, 8387 insertions(+)
 create mode 100644 .github/workflows/pages.yml
 create mode 100644 Gemfile
 create mode 100644 SITE_README.md
 create mode 100644 _config.yml
 create mode 100644 _docs/API_REFERENCE.md
 create mode 100644 _docs/ARCHITECTURE.md
 create mode 100644 _docs/CONFIGURATION.md
 create mode 100644 _docs/DEPLOYMENT.md
 create mode 100644 _docs/EXAMPLES.md
 create mode 100644 _docs/ONBOARDING.md
 create mode 100644 _docs/README.md
 create mode 100644 _docs/benchmarks.md
 create mode 100644 _docs/developer/error_handling.md
 create mode 100644 _docs/docker-scaling.md
 create mode 100644 _docs/mcp-json-rpc-api.md
 create mode 100644 _docs/metrics.md
 create mode 100644 _docs/security-audit.md
 create mode 100644 _docs/timeout-configuration.md
 create mode 100644 _docs/web-service.md
 create mode 100644 _layouts/default.html
 create mode 100644 _layouts/docs.html
 create mode 100644 _layouts/home.html
 create mode 100644 assets/css/main.css
 create mode 100644 assets/images/favicon.svg
 create mode 100644 assets/images/logo.svg
 create mode 100644 assets/js/main.js
 create mode 100644 bookmarks.md
 create mode 100644 index.md
 create mode 100644 search.md

diff --git a/.github/workflows/pages.yml b/.github/workflows/pages.yml
new file mode 100644
index 0000000..7998fb2
--- /dev/null
+++ b/.github/workflows/pages.yml
@@ -0,0 +1,54 @@
+name: Deploy Documentation Site
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.1'
+          bundler-cache: true
+
+      - name: Setup Pages
+        id: pages
+        uses: actions/configure-pages@v4
+
+      - name: Build with Jekyll
+        run: bundle exec jekyll build --baseurl "${{ steps.pages.outputs.base_path }}"
+        env:
+          JEKYLL_ENV: production
+
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+
+  deploy:
+    if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master'
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index ec2f292..60d6c98 100644
--- a/.gitignore
+++ b/.gitignore
@@ -21,3 +21,11 @@ nohup.out
 # Test configurations
 config.test.json
 *.test.json
+
+# Jekyll & GitHub Pages
+_site/
+.sass-cache/
+.jekyll-cache/
+.jekyll-metadata
+vendor/
+Gemfile.lock
diff --git a/Gemfile b/Gemfile
new file mode 100644
index 0000000..4c91e66
--- /dev/null
+++ b/Gemfile
@@ -0,0 +1,22 @@
+source "https://rubygems.org"
+
+gem "jekyll", "~> 4.3"
+gem "jekyll-feed", "~> 0.12"
+gem "jekyll-sitemap"
+gem "jekyll-seo-tag"
+gem "jekyll-relative-links"
+gem "jekyll-optional-front-matter"
+gem "jekyll-readme-index"
+gem "jekyll-default-layout"
+gem "jekyll-titles-from-headings"
+
+platforms :mingw, :x64_mingw, :mswin, :jruby do
+  gem "tzinfo", ">= 1", "< 3"
+  gem "tzinfo-data"
+end
+
+gem "wdm", "~> 0.1.1", :platforms => [:mingw, :x64_mingw, :mswin]
+gem "http_parser.rb", "~> 0.6.0", :platforms => [:jruby]
+
+# Security
+gem "webrick", "~> 1.8"
\ No newline at end of file
diff --git a/SITE_README.md b/SITE_README.md
new file mode 100644
index 0000000..08f47fc
--- /dev/null
+++ b/SITE_README.md
@@ -0,0 +1,227 @@
+# 📚 Solana MCP Server Documentation Site
+
+This repository hosts a modern, e-ink inspired documentation website for the Solana MCP Server project, built with Jekyll and deployed on GitHub Pages.
+
+## 🎨 Features
+
+### Modern E-ink Design
+- **Grayscale color palette** inspired by e-reader aesthetics
+- **Clean typography** using Inter and JetBrains Mono fonts
+- **Minimalist interface** focusing on content readability
+- **Responsive design** that works on all devices
+
+### Advanced Functionality
+- **🔍 Full-text search** powered by Lunr.js
+- **📖 Bookmark system** with local storage persistence
+- **🧭 Smart navigation** with breadcrumbs and page navigation
+- **📱 Mobile-optimized** responsive design
+- **♿ Accessibility features** including skip links and ARIA labels
+
+### Content Organization
+- **Comprehensive documentation** covering all 47 RPC methods
+- **Step-by-step guides** for deployment and configuration
+- **Interactive examples** with code snippets
+- **Architecture diagrams** and system overviews
+- **Security audit reports** and best practices
+
+## 🛠️ Technical Stack
+
+- **Static Site Generator**: Jekyll 4.3+
+- **Styling**: Custom CSS with CSS Grid and Flexbox
+- **Search**: Lunr.js full-text search
+- **Icons**: Custom SVG icons and emojis
+- **Deployment**: GitHub Actions → GitHub Pages
+- **Performance**: Optimized CSS/JS, lazy loading, service worker
+
+## 🚀 Local Development
+
+### Prerequisites
+- Ruby 3.1+
+- Bundler
+- Git
+
+### Setup
+```bash
+# Clone the repository
+git clone https://github.com/openSVM/solana-mcp-server.git
+cd solana-mcp-server
+
+# Install dependencies
+bundle install
+
+# Serve locally
+bundle exec jekyll serve
+
+# View at http://localhost:4000
+```
+
+### Development Commands
+```bash
+# Build the site
+bundle exec jekyll build
+
+# Serve with live reload
+bundle exec jekyll serve --livereload
+
+# Build for production
+JEKYLL_ENV=production bundle exec jekyll build
+```
+
+## 📁 Site Structure
+
+```
+├── _config.yml              # Jekyll configuration
+├── _layouts/                 # Page templates
+│   ├── default.html         # Base layout with navigation
+│   ├── home.html            # Homepage layout
+│   └── docs.html            # Documentation layout
+├── _docs/                   # Documentation collection
+│   ├── ONBOARDING.md        # Quick start guide
+│   ├── API_REFERENCE.md     # Complete API docs
+│   ├── ARCHITECTURE.md      # System architecture
+│   ├── DEPLOYMENT.md        # Deployment guides
+│   └── ...
+├── assets/
+│   ├── css/main.css         # E-ink themed styles
+│   ├── js/main.js          # Search & bookmark functionality
+│   └── images/             # Logos and icons
+├── index.md                # Homepage content
+├── search.md               # Search page
+├── bookmarks.md            # Bookmarks page
+└── Gemfile                 # Ruby dependencies
+```
+
+## 🎯 Content Guidelines
+
+### Writing Style
+- **Clear and concise** technical writing
+- **Step-by-step instructions** with code examples
+- **Consistent terminology** across all pages
+- **Practical examples** that users can follow
+
+### Documentation Organization
+- **Progressive disclosure** from basic to advanced concepts
+- **Cross-references** between related topics
+- **Code examples** with proper syntax highlighting
+- **Visual aids** like diagrams and screenshots
+
+### Markdown Conventions
+```markdown
+---
+layout: docs
+title: "Page Title"
+description: "Brief description"
+order: 1
+category: getting_started
+---
+
+# Page Title
+
+Brief introduction paragraph.
+
+## Section Header
+
+Content with `inline code` and:
+
+```bash
+# Code blocks with language specification
+command --with --arguments
+```
+
+> **Note**: Important callouts in blockquotes
+
+- Bullet points for lists
+- Use emojis sparingly for visual interest
+```
+
+## 🔧 Customization
+
+### Theme Colors
+Edit CSS custom properties in `/assets/css/main.css`:
+```css
+:root {
+  --eink-white: #ffffff;
+  --eink-paper: #fafafa;
+  --eink-light-gray: #f5f5f5;
+  --accent-teal: #2d5f5f;
+  /* ... */
+}
+```
+
+### Navigation
+Update navigation in `_config.yml`:
+```yaml
+nav_links:
+  - title: "Documentation"
+    url: "/docs/"
+  - title: "API Reference"
+    url: "/docs/API_REFERENCE/"
+```
+
+### Search Configuration
+Search is automatically configured but can be customized in `/assets/js/main.js`.
+
+## 📊 Analytics & Performance
+
+### Built-in Features
+- **Performance monitoring** with Core Web Vitals
+- **Search analytics** tracking user engagement
+- **Bookmark usage** metrics
+- **Mobile responsiveness** testing
+
+### Optimization
+- **CSS minification** in production builds
+- **Image optimization** with lazy loading
+- **Service worker** for offline functionality
+- **CDN delivery** via GitHub Pages
+
+## 🚀 Deployment
+
+### Automatic Deployment
+The site automatically deploys to GitHub Pages when changes are pushed to the main branch via GitHub Actions.
+
+### Manual Deployment
+```bash
+# Build for production
+JEKYLL_ENV=production bundle exec jekyll build
+
+# Deploy to GitHub Pages
+# (Handled automatically by GitHub Actions)
+```
+
+### Custom Domain
+To use a custom domain:
+1. Add CNAME file with your domain
+2. Configure DNS settings
+3. Enable HTTPS in repository settings
+
+## 🤝 Contributing
+
+### Content Updates
+1. Edit markdown files in `_docs/` directory
+2. Follow existing naming conventions
+3. Add appropriate front matter
+4. Test locally before submitting PR
+
+### Design Changes
+1. Modify CSS in `/assets/css/main.css`
+2. Maintain grayscale e-ink aesthetic
+3. Test across different screen sizes
+4. Ensure accessibility compliance
+
+### New Features  
+1. Add JavaScript to `/assets/js/main.js`
+2. Update templates in `_layouts/` if needed
+3. Document new features in this README
+4. Test thoroughly across browsers
+
+## 📝 License
+
+This documentation site is part of the Solana MCP Server project and is licensed under the MIT License.
+
+## 🔗 Links
+
+- **Live Site**: https://opensvm.github.io/solana-mcp-server/
+- **Main Repository**: https://github.com/openSVM/solana-mcp-server
+- **Issues**: https://github.com/openSVM/solana-mcp-server/issues
+- **Jekyll Documentation**: https://jekyllrb.com/docs/
\ No newline at end of file
diff --git a/_config.yml b/_config.yml
new file mode 100644
index 0000000..3c12365
--- /dev/null
+++ b/_config.yml
@@ -0,0 +1,129 @@
+# Site settings
+title: "Solana MCP Server Documentation"
+description: "A comprehensive Model Context Protocol server for Solana blockchain integration"
+baseurl: "/solana-mcp-server"
+url: "https://opensvm.github.io"
+
+# Repository
+repository: "openSVM/solana-mcp-server"
+github:
+  repository_url: "https://github.com/openSVM/solana-mcp-server"
+  repository_nwo: "openSVM/solana-mcp-server"
+
+# Build settings
+markdown: kramdown
+highlighter: rouge
+kramdown:
+  input: GFM
+  syntax_highlighter: rouge
+  syntax_highlighter_opts:
+    css_class: 'highlight'
+    span:
+      line_numbers: false
+    block:
+      line_numbers: true
+
+# Plugins
+plugins:
+  - jekyll-feed
+  - jekyll-sitemap
+  - jekyll-seo-tag
+  - jekyll-relative-links
+  - jekyll-optional-front-matter
+  - jekyll-readme-index
+  - jekyll-default-layout
+  - jekyll-titles-from-headings
+
+# Plugin settings
+relative_links:
+  enabled: true
+  collections: true
+
+optional_front_matter:
+  enabled: true
+
+readme_index:
+  enabled: true
+
+default_layout:
+  enabled: true
+
+titles_from_headings:
+  enabled: true
+  strip_title: true
+  collections: true
+
+# Collections
+collections:
+  docs:
+    output: true
+    permalink: /:collection/:name/
+
+# Navigation
+nav_links:
+  - title: "Home"
+    url: "/"
+  - title: "Quick Start"
+    url: "/docs/ONBOARDING/"
+  - title: "Architecture"
+    url: "/docs/ARCHITECTURE/"
+  - title: "API Reference"
+    url: "/docs/API_REFERENCE/"
+  - title: "Deployment"
+    url: "/docs/DEPLOYMENT/"
+  - title: "Configuration"
+    url: "/docs/CONFIGURATION/"
+  - title: "Examples"
+    url: "/docs/EXAMPLES/"
+
+# Site categories for organization
+categories:
+  getting_started:
+    title: "Getting Started"
+    description: "Quick start guides and onboarding"
+    icon: "🚀"
+  architecture:
+    title: "Architecture"
+    description: "System design and internals"
+    icon: "🏗️"
+  api:
+    title: "API Reference"
+    description: "Complete method documentation"
+    icon: "📖"
+  deployment:
+    title: "Deployment"
+    description: "Deployment guides and scaling"
+    icon: "🚀"
+  configuration:
+    title: "Configuration"
+    description: "Settings and customization"
+    icon: "⚙️"
+
+# Theme settings
+theme_config:
+  color_scheme: "eink"
+  logo: "/assets/images/logo.svg"
+  search_enabled: true
+  bookmark_enabled: true
+  responsive: true
+
+# SEO
+author: "openSVM"
+twitter:
+  username: "openSVM"
+
+# Exclude from processing
+exclude:
+  - .gitignore
+  - .github/
+  - Cargo.toml
+  - Cargo.lock
+  - src/
+  - target/
+  - tests/
+  - benches/
+  - scripts/
+  - k8s/
+  - "*.log"
+  - "*.sh"
+  - "*.rs"
\ No newline at end of file
diff --git a/_docs/API_REFERENCE.md b/_docs/API_REFERENCE.md
new file mode 100644
index 0000000..046fe4a
--- /dev/null
+++ b/_docs/API_REFERENCE.md
@@ -0,0 +1,592 @@
+---
+layout: docs
+title: "API Reference"
+description: "Complete documentation of all 47 RPC methods with parameters, examples, and response formats"
+order: 3
+category: api
+---
+
+# API Reference
+
+## Overview
+
+The Solana MCP Server exposes 47 comprehensive RPC methods across 6 major categories, plus 4 network management methods. All methods support both single-network and multi-network execution modes.
+
+## Network Management Methods
+
+### `listSvmNetworks`
+Lists all available SVM-compatible networks from the awesome-svm registry.
+
+**Parameters:** None
+
+**Response:**
+```json
+{
+  "networks": [
+    {
+      "id": "solana-mainnet",
+      "name": "Solana Mainnet",
+      "rpc_url": "https://api.mainnet-beta.solana.com",
+      "chain_id": "solana",
+      "type": "mainnet"
+    }
+  ]
+}
+```
+
+**Example:**
+```
+User: "Show me all available SVM networks"
+Response: Lists networks from https://raw.githubusercontent.com/openSVM/awesome-svm/refs/heads/main/svm-networks.json
+```
+
+### `enableSvmNetwork`
+Enables a network for multi-network queries.
+
+**Parameters:**
+- `network_id` (string): Network identifier to enable
+
+**Example:**
+```
+User: "Enable the Eclipse mainnet network"
+```
+
+### `disableSvmNetwork`
+Disables a network from multi-network queries.
+
+**Parameters:**
+- `network_id` (string): Network identifier to disable
+
+### `setNetworkRpcUrl`
+Override the RPC URL for a specific network.
+
+**Parameters:**
+- `network_id` (string): Network identifier
+- `rpc_url` (string): Custom RPC endpoint URL
+
+**Example:**
+```
+User: "Set a custom RPC URL for Solana mainnet"
+```
+
+## Account Methods
+
+### `getAccountInfo`
+Returns all information associated with the account of provided Pubkey.
+
+**Parameters:**
+- `pubkey` (string): Pubkey of account to query, as base-58 encoded string
+- `commitment` (string, optional): Commitment level (processed|confirmed|finalized)
+- `encoding` (string, optional): Data encoding (base58|base64|jsonParsed)
+
+**Single Network Response:**
+```json
+{
+  "context": { "slot": 123456 },
+  "value": {
+    "data": ["base64-encoded-data", "base64"],
+    "executable": false,
+    "lamports": 1000000000,
+    "owner": "11111111111111111111111111111112",
+    "rentEpoch": 361
+  }
+}
+```
+
+**Multi-Network Response:**
+```json
+{
+  "solana-mainnet": {
+    "context": { "slot": 123456 },
+    "value": { /* account info */ }
+  },
+  "eclipse-mainnet": {
+    "context": { "slot": 123450 },
+    "value": { /* account info */ }
+  }
+}
+```
+
+### `getBalance`
+Returns the SOL balance of an account.
+
+**Parameters:**
+- `pubkey` (string): Account Pubkey to query
+
+**Response:**
+```json
+{
+  "context": { "slot": 123456 },
+  "value": 1000000000
+}
+```
+
+### `getMultipleAccounts`
+Returns account information for multiple Pubkeys.
+
+**Parameters:**
+- `pubkeys` (array of strings): List of Pubkeys to query
+- `commitment` (string, optional): Commitment level
+
+### `getProgramAccounts`
+Returns all accounts owned by the provided program Pubkey.
+
+**Parameters:**
+- `programId` (string): Program Pubkey to query
+- `commitment` (string, optional): Commitment level
+- `filters` (array, optional): Filter criteria
+- `encoding` (string, optional): Data encoding
+
+### `getLargestAccounts`
+Returns the 20 largest accounts by lamport balance.
+
+**Parameters:**
+- `commitment` (string, optional): Commitment level
+- `filter` (string, optional): Filter by account type (circulating|nonCirculating)
+
+### `getMinimumBalanceForRentExemption`
+Returns minimum balance for rent exemption.
+
+**Parameters:**
+- `dataSize` (integer): Size of account data in bytes
+
+**Response:**
+```json
+{
+  "value": 890880
+}
+```
+
+## Block Methods
+
+### `getBlock`
+Returns identity and transaction information about a confirmed block.
+
+**Parameters:**
+- `slot` (integer): Slot number to query
+- `commitment` (string, optional): Commitment level
+- `encoding` (string, optional): Transaction encoding
+- `transactionDetails` (string, optional): Level of transaction detail
+- `rewards` (boolean, optional): Include rewards
+
+### `getBlocks`
+Returns a list of confirmed blocks between two slots.
+
+**Parameters:**
+- `start_slot` (integer): Start slot (inclusive)
+- `end_slot` (integer, optional): End slot (inclusive)
+
+### `getBlocksWithLimit`
+Returns a list of confirmed blocks starting at given slot.
+
+**Parameters:**
+- `start_slot` (integer): Start slot
+- `limit` (integer): Maximum number of blocks to return
+
+### `getBlockTime`
+Returns estimated production time of a block.
+
+**Parameters:**
+- `slot` (integer): Block slot to query
+
+**Response:**
+```json
+{
+  "value": 1627852800
+}
+```
+
+### `getBlockHeight`
+Returns current block height.
+
+**Parameters:** None
+
+**Response:**
+```json
+{
+  "value": 123456789
+}
+```
+
+### `getBlockCommitment`
+Returns commitment for particular block.
+
+**Parameters:**
+- `slot` (integer): Block slot to query
+
+### `getBlockProduction`
+Returns recent block production information.
+
+**Parameters:**
+- `commitment` (string, optional): Commitment level
+- `range` (object, optional): Slot range to query
+- `identity` (string, optional): Validator identity pubkey
+
+### `getSlot`
+Returns the current slot the node is processing.
+
+**Parameters:**
+- `commitment` (string, optional): Commitment level
+
+**Response:**
+```json
+{
+  "value": 123456789
+}
+```
+
+### `getSlotLeaders`
+Returns slot leaders for a given slot range.
+
+**Parameters:**
+- `startSlot` (integer): Start slot
+- `limit` (integer): Number of leaders to return
+
+### `getFirstAvailableBlock`
+Returns the lowest confirmed block still available.
+
+**Parameters:** None
+
+**Response:**
+```json
+{
+  "value": 123000000
+}
+```
+
+### `getGenesisHash`
+Returns the genesis hash of the ledger.
+
+**Parameters:** None
+
+**Response:**
+```json
+{
+  "value": "genesis-hash-string"
+}
+```
+
+## System Methods
+
+### `getHealth`
+Returns current health status of the node.
+
+**Parameters:** None
+
+**Response:**
+```json
+"ok"
+```
+
+### `getVersion`
+Returns current Solana version running on the node.
+
+**Parameters:** None
+
+**Response:**
+```json
+{
+  "solana-core": "1.16.0",
+  "feature-set": 123456789
+}
+```
+
+### `getIdentity`
+Returns identity pubkey for the current node.
+
+**Parameters:** None
+
+### `getClusterNodes`
+Returns information about all cluster nodes.
+
+**Parameters:** None
+
+### `getLeaderSchedule`
+Returns the leader schedule for an epoch.
+
+**Parameters:**
+- `slot` (integer, optional): Slot number to query
+- `commitment` (string, optional): Commitment level
+- `identity` (string, optional): Validator identity
+
+### `getVoteAccounts`
+Returns account info and stake for all voting accounts.
+
+**Parameters:**
+- `commitment` (string, optional): Commitment level
+- `votePubkey` (string, optional): Specific vote account
+- `keepUnstakedDelinquents` (boolean, optional): Include unstaked delinquents
+- `delinquentSlotDistance` (integer, optional): Delinquent slot distance
+
+## Epoch and Inflation Methods
+
+### `getEpochInfo`
+Returns information about the current epoch.
+
+**Parameters:**
+- `commitment` (string, optional): Commitment level
+
+**Response:**
+```json
+{
+  "absoluteSlot": 123456789,
+  "blockHeight": 123456789,
+  "epoch": 300,
+  "slotIndex": 123456,
+  "slotsInEpoch": 432000,
+  "transactionCount": 987654321
+}
+```
+
+### `getEpochSchedule`
+Returns epoch schedule information.
+
+**Parameters:** None
+
+### `getInflationGovernor`
+Returns current inflation governor.
+
+**Parameters:**
+- `commitment` (string, optional): Commitment level
+
+### `getInflationRate`
+Returns specific inflation values for current epoch.
+
+**Parameters:** None
+
+### `getInflationReward`
+Returns inflation reward for list of addresses.
+
+**Parameters:**
+- `addresses` (array of strings): List of addresses to query
+- `epoch` (integer, optional): Epoch to query
+- `commitment` (string, optional): Commitment level
+
+## Token Methods
+
+### `getTokenAccountBalance`
+Returns token balance of an SPL Token account.
+
+**Parameters:**
+- `accountAddress` (string): Token account to query
+- `commitment` (string, optional): Commitment level
+
+**Response:**
+```json
+{
+  "context": { "slot": 123456 },
+  "value": {
+    "amount": "1000000000",
+    "decimals": 9,
+    "uiAmount": 1.0,
+    "uiAmountString": "1"
+  }
+}
+```
+
+### `getTokenAccountsByDelegate`
+Returns all token accounts by approved delegate.
+
+**Parameters:**
+- `delegateAddress` (string): Delegate address
+- `mint` (string, optional): Specific token mint
+- `programId` (string, optional): Token program ID
+- `commitment` (string, optional): Commitment level
+
+### `getTokenAccountsByOwner`
+Returns all token accounts by token owner.
+
+**Parameters:**
+- `ownerAddress` (string): Owner address
+- `mint` (string, optional): Specific token mint
+- `programId` (string, optional): Token program ID
+
+### `getTokenLargestAccounts`
+Returns 20 largest accounts of a token type.
+
+**Parameters:**
+- `mint` (string): Token mint to query
+- `commitment` (string, optional): Commitment level
+
+### `getTokenSupply`
+Returns total supply of an SPL Token type.
+
+**Parameters:**
+- `mint` (string): Token mint to query
+- `commitment` (string, optional): Commitment level
+
+## Transaction Methods
+
+### `getTransaction`
+Returns transaction details for confirmed transaction.
+
+**Parameters:**
+- `signature` (string): Transaction signature
+- `commitment` (string, optional): Commitment level
+- `encoding` (string, optional): Transaction encoding
+- `maxSupportedTransactionVersion` (integer, optional): Max transaction version
+
+### `getSignaturesForAddress`
+Returns signatures for address's transactions.
+
+**Parameters:**
+- `address` (string): Account address
+- `limit` (integer, optional): Maximum signatures to return
+- `before` (string, optional): Start searching backwards from this signature
+- `until` (string, optional): Search until this signature
+- `commitment` (string, optional): Commitment level
+
+### `getSignatureStatuses`
+Returns statuses of a list of signatures.
+
+**Parameters:**
+- `signatures` (array of strings): Transaction signatures
+- `searchTransactionHistory` (boolean, optional): Search full transaction history
+
+### `getTransactionCount`
+Returns current Transaction count from ledger.
+
+**Parameters:**
+- `commitment` (string, optional): Commitment level
+
+**Response:**
+```json
+{
+  "value": 987654321
+}
+```
+
+### `simulateTransaction`
+Simulate sending a transaction.
+
+**Parameters:**
+- `transaction` (string): Encoded transaction
+- `commitment` (string, optional): Commitment level
+- `encoding` (string, optional): Transaction encoding
+- `replaceRecentBlockhash` (boolean, optional): Replace recent blockhash
+- `accounts` (object, optional): Account configurations
+
+### `sendTransaction`
+Send a transaction to the network.
+
+**Parameters:**
+- `transaction` (string): Signed encoded transaction
+- `encoding` (string, optional): Transaction encoding
+- `skipPreflight` (boolean, optional): Skip preflight checks
+- `preflightCommitment` (string, optional): Preflight commitment level
+- `maxRetries` (integer, optional): Maximum retry attempts
+
+## Other Methods
+
+### `getFeeForMessage`
+Get the fee for a message.
+
+**Parameters:**
+- `message` (string): Base64 encoded message
+- `commitment` (string, optional): Commitment level
+
+### `getLatestBlockhash`
+Returns the latest blockhash.
+
+**Parameters:**
+- `commitment` (string, optional): Commitment level
+
+**Response:**
+```json
+{
+  "context": { "slot": 123456 },
+  "value": {
+    "blockhash": "blockhash-string",
+    "lastValidBlockHeight": 123456
+  }
+}
+```
+
+### `isBlockhashValid`
+Returns whether a blockhash is still valid.
+
+**Parameters:**
+- `blockhash` (string): Blockhash to validate
+- `commitment` (string, optional): Commitment level
+
+### `getStakeMinimumDelegation`
+Returns stake minimum delegation.
+
+**Parameters:**
+- `commitment` (string, optional): Commitment level
+
+### `getSupply`
+Returns information about current supply.
+
+**Parameters:**
+- `commitment` (string, optional): Commitment level
+- `excludeNonCirculatingAccountsList` (boolean, optional): Exclude non-circulating accounts
+
+### `requestAirdrop`
+Request an airdrop of lamports to a Pubkey (devnet/testnet only).
+
+**Parameters:**
+- `pubkey` (string): Recipient address
+- `lamports` (integer): Amount to airdrop
+- `commitment` (string, optional): Commitment level
+
+## Error Handling
+
+### Common Error Codes
+
+- `-32700`: Parse error
+- `-32600`: Invalid request
+- `-32601`: Method not found
+- `-32602`: Invalid params
+- `-32603`: Internal error
+- `-32000`: Server error
+
+### Error Response Format
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "error": {
+    "code": -32602,
+    "message": "Invalid params",
+    "data": {
+      "protocolVersion": "2024-11-05"
+    }
+  }
+}
+```
+
+## Rate Limiting
+
+The server implements rate limiting to prevent abuse:
+
+- **Default Limit**: 100 requests per minute per client
+- **Burst Limit**: 10 requests per second
+- **Multi-Network Impact**: Each enabled network counts as one request
+
+## Usage Examples
+
+### Natural Language Queries
+
+```
+User: "What's the SOL balance of address Gh9ZwEmdLJ8DscKNTkTqPbNwLNNBjuSzaG9Vp2KGtKJr?"
+Assistant: [Calls getBalance with the provided address]
+
+User: "Show me the current slot number on all enabled networks"
+Assistant: [Calls getSlot on all enabled SVM networks]
+
+User: "Get the token supply for USDC"
+Assistant: [Calls getTokenSupply with USDC mint address]
+```
+
+### Direct API Calls
+
+```bash
+# Single network call
+echo '{"method": "getBalance", "params": {"pubkey": "Gh9ZwEmdLJ8DscKNTkTqPbNwLNNBjuSzaG9Vp2KGtKJr"}}' | \
+  solana-mcp-server
+
+# Multi-network setup
+echo '{"method": "enableSvmNetwork", "params": {"network_id": "eclipse-mainnet"}}' | \
+  solana-mcp-server
+```
\ No newline at end of file
diff --git a/_docs/ARCHITECTURE.md b/_docs/ARCHITECTURE.md
new file mode 100644
index 0000000..f84cef3
--- /dev/null
+++ b/_docs/ARCHITECTURE.md
@@ -0,0 +1,248 @@
+---
+layout: docs
+title: "Architecture Overview"
+description: "System design, component interactions, and internal workings of the MCP server"
+order: 2
+category: architecture
+---
+
+# Solana MCP Server Architecture
+
+## Overview
+
+The Solana MCP Server is a Model Context Protocol (MCP) implementation that provides comprehensive access to Solana blockchain data through AI assistants like Claude. It acts as a bridge between natural language conversations and Solana RPC endpoints, enabling users to query blockchain information conversationally.
+
+## System Architecture
+
+```mermaid
+graph TB
+    subgraph "Client Layer"
+        A[Claude Desktop/IDE] --> B[MCP Client]
+    end
+    
+    subgraph "MCP Server"
+        B --> C[Transport Layer]
+        C --> D[Request Handler]
+        D --> E[Tool Dispatcher]
+        E --> F[RPC Manager]
+        F --> G[Multi-Network Router]
+    end
+    
+    subgraph "Configuration"
+        H[Config.json] --> F
+        I[Environment Variables] --> F
+        J[SVM Networks Registry] --> G
+    end
+    
+    subgraph "Blockchain Networks"
+        G --> K[Solana Mainnet]
+        G --> L[Solana Devnet]
+        G --> M[Other SVM Networks]
+        G --> N[Custom RPC Endpoints]
+    end
+    
+    style A fill:#e1f5fe
+    style B fill:#f3e5f5
+    style C fill:#fff3e0
+    style D fill:#fff3e0
+    style E fill:#fff3e0
+    style F fill:#fff3e0
+    style G fill:#fff3e0
+    style H fill:#f1f8e9
+    style I fill:#f1f8e9
+    style J fill:#f1f8e9
+    style K fill:#ffebee
+    style L fill:#ffebee
+    style M fill:#ffebee
+    style N fill:#ffebee
+```
+
+## Core Components
+
+### 1. Transport Layer
+- **Protocol**: JSON-RPC 2.0 over stdio
+- **Communication**: Bidirectional message passing
+- **Serialization**: JSON with serde
+- **Error Handling**: Structured error responses with protocol version
+
+### 2. Request Handler
+- **Initialization**: MCP protocol handshake
+- **Tool Discovery**: Dynamic tool listing
+- **Request Routing**: Method-based dispatch
+- **Response Formatting**: Standardized JSON-RPC responses
+
+### 3. Multi-Network Router
+- **Network Management**: Dynamic SVM network configuration
+- **Load Balancing**: Parallel requests across enabled networks
+- **Result Aggregation**: Unified response format for multi-network queries
+- **Fallback Handling**: Graceful degradation on network failures
+
+### 4. RPC Manager
+- **Client Pool**: Persistent Solana RPC client connections
+- **Commitment Levels**: Configurable transaction confirmation levels
+- **Rate Limiting**: Built-in request throttling
+- **Error Recovery**: Automatic retry mechanisms
+
+## Request Flow
+
+```mermaid
+sequenceDiagram
+    participant C as Claude
+    participant M as MCP Server
+    participant S as Solana RPC
+    participant N as Other SVM Networks
+    
+    C->>M: Initialize MCP Connection
+    M-->>C: Server Capabilities
+    
+    C->>M: tools/list Request
+    M-->>C: Available Tools List
+    
+    C->>M: tools/call: getBalance
+    M->>M: Parse Parameters
+    M->>M: Check Enabled Networks
+    
+    alt Single Network Mode
+        M->>S: getBalance RPC Call
+        S-->>M: Account Balance
+        M-->>C: Direct Response
+    else Multi-Network Mode
+        par Parallel Network Calls
+            M->>S: getBalance RPC Call
+            M->>N: getBalance RPC Call
+        end
+        S-->>M: Mainnet Balance
+        N-->>M: Network Balance
+        M->>M: Aggregate Results
+        M-->>C: Multi-Network Response
+    end
+```
+
+## Data Flow Architecture
+
+```mermaid
+flowchart LR
+    subgraph "Input Processing"
+        A[Natural Language Query] --> B[MCP Protocol]
+        B --> C[Tool Identification]
+        C --> D[Parameter Extraction]
+    end
+    
+    subgraph "Network Layer"
+        D --> E{Network Mode}
+        E -->|Single| F[Primary RPC Client]
+        E -->|Multi| G[Network Router]
+        G --> H[Solana Mainnet]
+        G --> I[Solana Devnet]
+        G --> J[Custom Networks]
+    end
+    
+    subgraph "Response Processing"
+        F --> K[Format Response]
+        H --> L[Aggregate Results]
+        I --> L
+        J --> L
+        L --> K
+        K --> M[JSON-RPC Response]
+    end
+    
+    subgraph "Output"
+        M --> N[MCP Protocol]
+        N --> O[Natural Language Response]
+    end
+```
+
+## Multi-Network Support
+
+The server supports querying multiple SVM-compatible networks simultaneously:
+
+### Network Configuration
+```json
+{
+  "svm_networks": {
+    "solana-mainnet": {
+      "name": "Solana Mainnet",
+      "rpc_url": "https://api.mainnet-beta.solana.com",
+      "enabled": true
+    },
+    "solana-devnet": {
+      "name": "Solana Devnet", 
+      "rpc_url": "https://api.devnet.solana.com",
+      "enabled": false
+    }
+  }
+}
+```
+
+### Response Formats
+
+**Single Network Response:**
+```json
+{
+  "value": 1000000000,
+  "context": {
+    "slot": 12345
+  }
+}
+```
+
+**Multi-Network Response:**
+```json
+{
+  "solana-mainnet": {
+    "value": 1000000000,
+    "context": { "slot": 12345 }
+  },
+  "custom-network": {
+    "value": 500000000,
+    "context": { "slot": 12340 }
+  }
+}
+```
+
+## Security Model
+
+```mermaid
+graph TD
+    A[External Request] --> B[Input Validation]
+    B --> C[Parameter Sanitization]
+    C --> D[Rate Limiting]
+    D --> E[Network Authorization]
+    E --> F[RPC Client Security]
+    F --> G[Response Filtering]
+    G --> H[Output Sanitization]
+    
+    style B fill:#ffcdd2
+    style C fill:#ffcdd2
+    style D fill:#fff3e0
+    style E fill:#fff3e0
+    style F fill:#e8f5e8
+    style G fill:#e8f5e8
+    style H fill:#ffcdd2
+```
+
+### Security Features
+- **Input Validation**: Strict parameter type checking
+- **Rate Limiting**: Prevents RPC endpoint abuse
+- **Network Isolation**: Sandboxed network configurations
+- **Error Sanitization**: Prevents information leakage
+- **Read-Only Operations**: No transaction signing or sending by default
+
+## Performance Characteristics
+
+### Latency Profile
+- **Local Processing**: < 1ms
+- **Single Network RPC**: 100-500ms (network dependent)
+- **Multi-Network Queries**: 200-800ms (parallel execution)
+- **Network Discovery**: 1-3s (cached after first load)
+
+### Scalability
+- **Concurrent Requests**: Limited by RPC endpoint rate limits
+- **Memory Usage**: ~10MB base + ~2MB per active network
+- **CPU Usage**: Minimal for request routing and JSON processing
+
+### Optimization Features
+- **Connection Pooling**: Persistent RPC client connections
+- **Response Caching**: Configurable caching for static data
+- **Parallel Execution**: Simultaneous multi-network queries
+- **Lazy Loading**: Networks initialized on first use
\ No newline at end of file
diff --git a/_docs/CONFIGURATION.md b/_docs/CONFIGURATION.md
new file mode 100644
index 0000000..a5b1e02
--- /dev/null
+++ b/_docs/CONFIGURATION.md
@@ -0,0 +1,537 @@
+---
+layout: docs
+title: "Configuration Guide"
+description: "Comprehensive guide to configuration options, environment variables, and customization"
+order: 5
+category: configuration
+---
+
+# Configuration Guide
+
+## Overview
+
+The Solana MCP Server supports flexible configuration through multiple sources with a clear precedence hierarchy. This guide covers all configuration options, formats, and best practices.
+
+## Configuration Sources
+
+```mermaid
+graph TD
+    A[Configuration Loading] --> B{config.json exists?}
+    B -->|Yes| C[Load from config.json]
+    B -->|No| D[Load from Environment Variables]
+    C --> E[Validate Configuration]
+    D --> E
+    E --> F{Valid?}
+    F -->|Yes| G[Initialize Server]
+    F -->|No| H[Use Defaults + Error Logging]
+    H --> G
+    
+    style A fill:#e3f2fd
+    style C fill:#e8f5e8
+    style D fill:#fff3e0
+    style E fill:#f3e5f5
+    style G fill:#e3f2fd
+    style H fill:#ffebee
+```
+
+## Configuration Hierarchy
+
+1. **config.json** (highest priority)
+2. **Environment Variables** (fallback)
+3. **Default Values** (last resort)
+
+## Configuration File Format
+
+### Basic Configuration
+
+```json
+{
+  "rpc_url": "https://api.mainnet-beta.solana.com",
+  "commitment": "confirmed",
+  "protocol_version": "2024-11-05"
+}
+```
+
+### Complete Configuration
+
+```json
+{
+  "rpc_url": "https://api.mainnet-beta.solana.com",
+  "commitment": "confirmed",
+  "protocol_version": "2024-11-05",
+  "svm_networks": {
+    "solana-mainnet": {
+      "name": "Solana Mainnet",
+      "rpc_url": "https://api.mainnet-beta.solana.com",
+      "enabled": true
+    },
+    "solana-devnet": {
+      "name": "Solana Devnet",
+      "rpc_url": "https://api.devnet.solana.com",
+      "enabled": false
+    },
+    "eclipse-mainnet": {
+      "name": "Eclipse Mainnet",
+      "rpc_url": "https://mainnetbeta-rpc.eclipse.xyz",
+      "enabled": false
+    },
+    "custom-network": {
+      "name": "Custom Development Network",
+      "rpc_url": "https://my-custom-rpc.example.com",
+      "enabled": false
+    }
+  },
+  "server_config": {
+    "max_concurrent_requests": 100,
+    "request_timeout_ms": 30000,
+    "retry_attempts": 3,
+    "retry_delay_ms": 1000,
+    "enable_logging": true,
+    "log_level": "info"
+  },
+  "cache_config": {
+    "enable_caching": true,
+    "cache_ttl_seconds": 300,
+    "max_cache_size": 1000
+  }
+}
+```
+
+## Environment Variables
+
+### Core Settings
+
+```bash
+# Primary RPC endpoint
+export SOLANA_RPC_URL="https://api.mainnet-beta.solana.com"
+
+# Commitment level (processed|confirmed|finalized)
+export SOLANA_COMMITMENT="confirmed"
+
+# Protocol version
+export SOLANA_PROTOCOL_VERSION="2024-11-05"
+
+# Logging level
+export RUST_LOG="info"
+```
+
+### Network Configuration
+
+```bash
+# Enable specific networks
+export SOLANA_ENABLED_NETWORKS="solana-mainnet,eclipse-mainnet"
+
+# Custom RPC URLs
+export SOLANA_MAINNET_RPC="https://api.mainnet-beta.solana.com"
+export ECLIPSE_MAINNET_RPC="https://mainnetbeta-rpc.eclipse.xyz"
+
+# Network-specific settings
+export SOLANA_DEVNET_ENABLED="false"
+export ECLIPSE_TESTNET_ENABLED="true"
+```
+
+### Performance Settings
+
+```bash
+# Request handling
+export MAX_CONCURRENT_REQUESTS="100"
+export REQUEST_TIMEOUT_MS="30000"
+export RETRY_ATTEMPTS="3"
+
+# Caching
+export ENABLE_CACHING="true"
+export CACHE_TTL_SECONDS="300"
+export MAX_CACHE_SIZE="1000"
+
+# Connection pooling
+export CONNECTION_POOL_SIZE="10"
+export CONNECTION_TIMEOUT_MS="5000"
+```
+
+## Network Management
+
+### Adding New Networks
+
+1. **Via Configuration File:**
+```json
+{
+  "svm_networks": {
+    "new-network": {
+      "name": "New SVM Network",
+      "rpc_url": "https://rpc.new-network.com",
+      "enabled": false
+    }
+  }
+}
+```
+
+2. **Via API Call:**
+```json
+{
+  "method": "setNetworkRpcUrl",
+  "params": {
+    "network_id": "new-network",
+    "rpc_url": "https://rpc.new-network.com"
+  }
+}
+```
+
+### Network Configuration Flow
+
+```mermaid
+sequenceDiagram
+    participant U as User
+    participant S as MCP Server
+    participant C as Config Manager
+    participant N as Network Manager
+    participant R as RPC Client Pool
+    
+    U->>S: setNetworkRpcUrl
+    S->>C: Update Configuration
+    C->>C: Validate RPC URL
+    C->>N: Update Network Registry
+    N->>R: Create/Update RPC Client
+    R-->>N: Client Ready
+    N-->>S: Network Updated
+    S-->>U: Success Response
+    
+    Note over C: Config saved to disk
+    Note over R: Connection pooling active
+```
+
+### Network States
+
+```mermaid
+stateDiagram-v2
+    [*] --> Disabled: Default State
+    Disabled --> Enabled: enableSvmNetwork()
+    Enabled --> Disabled: disableSvmNetwork()
+    Enabled --> Updating: setNetworkRpcUrl()
+    Updating --> Enabled: Update Complete
+    Updating --> Error: Invalid URL
+    Error --> Disabled: Reset Network
+    
+    note right of Enabled
+        Network available for
+        multi-network queries
+    end note
+    
+    note right of Disabled
+        Network excluded from
+        query operations
+    end note
+```
+
+## Configuration Validation
+
+### Validation Rules
+
+```rust
+// Configuration validation schema
+pub struct ConfigValidator;
+
+impl ConfigValidator {
+    pub fn validate(config: &Config) -> Result<(), ConfigError> {
+        // Validate RPC URL format
+        if !Self::is_valid_url(&config.rpc_url) {
+            return Err(ConfigError::InvalidRpcUrl(config.rpc_url.clone()));
+        }
+        
+        // Validate commitment level
+        if !["processed", "confirmed", "finalized"].contains(&config.commitment.as_str()) {
+            return Err(ConfigError::InvalidCommitment(config.commitment.clone()));
+        }
+        
+        // Validate protocol version format
+        if !Self::is_valid_protocol_version(&config.protocol_version) {
+            return Err(ConfigError::InvalidProtocolVersion(config.protocol_version.clone()));
+        }
+        
+        // Validate SVM networks
+        for (id, network) in &config.svm_networks {
+            if !Self::is_valid_url(&network.rpc_url) {
+                return Err(ConfigError::InvalidNetworkRpcUrl {
+                    network_id: id.clone(),
+                    url: network.rpc_url.clone(),
+                });
+            }
+        }
+        
+        Ok(())
+    }
+}
+```
+
+### Validation Errors
+
+```json
+{
+  "error": {
+    "code": -32603,
+    "message": "Configuration validation failed",
+    "data": {
+      "errors": [
+        {
+          "field": "svm_networks.custom-network.rpc_url",
+          "message": "Invalid URL format",
+          "value": "invalid-url"
+        }
+      ]
+    }
+  }
+}
+```
+
+## Security Configuration
+
+### Access Control
+
+```json
+{
+  "security_config": {
+    "allowed_origins": [
+      "https://claude.ai",
+      "https://localhost:3000"
+    ],
+    "rate_limiting": {
+      "requests_per_minute": 100,
+      "burst_limit": 10
+    },
+    "authentication": {
+      "require_api_key": false,
+      "api_key_header": "X-API-Key"
+    }
+  }
+}
+```
+
+### Network Security
+
+```json
+{
+  "network_security": {
+    "verify_ssl": true,
+    "connection_timeout_ms": 5000,
+    "read_timeout_ms": 30000,
+    "max_redirects": 3,
+    "user_agent": "solana-mcp-server/1.0.0"
+  }
+}
+```
+
+## Performance Configuration
+
+### Connection Pooling
+
+```json
+{
+  "connection_pool": {
+    "max_connections_per_host": 10,
+    "max_idle_connections": 5,
+    "idle_timeout_seconds": 300,
+    "connection_ttl_seconds": 3600
+  }
+}
+```
+
+### Caching Strategy
+
+```json
+{
+  "cache_config": {
+    "enable_caching": true,
+    "cache_layers": {
+      "network_info": {
+        "ttl_seconds": 3600,
+        "max_entries": 100
+      },
+      "account_info": {
+        "ttl_seconds": 30,
+        "max_entries": 1000
+      },
+      "block_info": {
+        "ttl_seconds": 600,
+        "max_entries": 500
+      }
+    }
+  }
+}
+```
+
+## Development Configuration
+
+### Local Development
+
+```json
+{
+  "rpc_url": "https://api.devnet.solana.com",
+  "commitment": "processed",
+  "svm_networks": {
+    "solana-devnet": {
+      "name": "Solana Devnet",
+      "rpc_url": "https://api.devnet.solana.com",
+      "enabled": true
+    }
+  },
+  "server_config": {
+    "enable_logging": true,
+    "log_level": "debug",
+    "request_timeout_ms": 10000
+  }
+}
+```
+
+### Testing Configuration
+
+```json
+{
+  "rpc_url": "https://api.testnet.solana.com",
+  "commitment": "confirmed",
+  "server_config": {
+    "max_concurrent_requests": 50,
+    "retry_attempts": 1,
+    "enable_logging": true,
+    "log_level": "trace"
+  },
+  "cache_config": {
+    "enable_caching": false
+  }
+}
+```
+
+## Production Configuration
+
+### High Performance
+
+```json
+{
+  "rpc_url": "https://api.mainnet-beta.solana.com",
+  "commitment": "confirmed",
+  "svm_networks": {
+    "solana-mainnet": {
+      "name": "Solana Mainnet",
+      "rpc_url": "https://my-dedicated-rpc.example.com",
+      "enabled": true
+    }
+  },
+  "server_config": {
+    "max_concurrent_requests": 500,
+    "request_timeout_ms": 15000,
+    "retry_attempts": 2,
+    "enable_logging": true,
+    "log_level": "warn"
+  },
+  "connection_pool": {
+    "max_connections_per_host": 20,
+    "connection_ttl_seconds": 1800
+  },
+  "cache_config": {
+    "enable_caching": true,
+    "cache_ttl_seconds": 120,
+    "max_cache_size": 5000
+  }
+}
+```
+
+### High Availability
+
+```json
+{
+  "rpc_url": "https://api.mainnet-beta.solana.com",
+  "svm_networks": {
+    "solana-mainnet-primary": {
+      "name": "Solana Mainnet (Primary)",
+      "rpc_url": "https://primary-rpc.example.com",
+      "enabled": true
+    },
+    "solana-mainnet-backup": {
+      "name": "Solana Mainnet (Backup)",
+      "rpc_url": "https://backup-rpc.example.com",
+      "enabled": true
+    }
+  },
+  "fallback_config": {
+    "enable_fallback": true,
+    "fallback_threshold_ms": 5000,
+    "health_check_interval_seconds": 30
+  }
+}
+```
+
+## Configuration Management Commands
+
+### Runtime Configuration Updates
+
+```bash
+# Update primary RPC URL
+solana-mcp-server config set rpc_url "https://new-rpc.example.com"
+
+# Enable network
+solana-mcp-server config network enable "eclipse-mainnet"
+
+# Set network RPC URL
+solana-mcp-server config network set-url "eclipse-mainnet" "https://custom-rpc.com"
+
+# View current configuration
+solana-mcp-server config show
+
+# Validate configuration
+solana-mcp-server config validate
+```
+
+### Configuration Backup and Restore
+
+```bash
+# Backup current configuration
+solana-mcp-server config backup config-backup.json
+
+# Restore from backup
+solana-mcp-server config restore config-backup.json
+
+# Reset to defaults
+solana-mcp-server config reset
+```
+
+## Troubleshooting
+
+### Common Configuration Issues
+
+1. **Invalid RPC URL Format**
+   ```
+   Error: Invalid RPC URL format: 'not-a-url'
+   Solution: Use full HTTP/HTTPS URLs
+   ```
+
+2. **Network Connectivity Issues**
+   ```
+   Error: Failed to connect to RPC endpoint
+   Solution: Check network connectivity and URL accessibility
+   ```
+
+3. **Configuration File Syntax Errors**
+   ```
+   Error: Failed to parse config.json: invalid JSON
+   Solution: Validate JSON syntax
+   ```
+
+### Configuration Validation Tool
+
+```bash
+# Validate configuration file
+jq empty config.json && echo "Valid JSON" || echo "Invalid JSON"
+
+# Test RPC connectivity
+curl -X POST -H "Content-Type: application/json" \
+  --data '{"jsonrpc":"2.0","id":1,"method":"getHealth"}' \
+  https://api.mainnet-beta.solana.com
+```
+
+### Debug Configuration Loading
+
+```bash
+# Enable debug logging for configuration loading
+RUST_LOG=solana_mcp_server::config=debug solana-mcp-server
+
+# Check which configuration source is being used
+solana-mcp-server --config-info
+```
\ No newline at end of file
diff --git a/_docs/DEPLOYMENT.md b/_docs/DEPLOYMENT.md
new file mode 100644
index 0000000..631e1b8
--- /dev/null
+++ b/_docs/DEPLOYMENT.md
@@ -0,0 +1,535 @@
+---
+layout: docs
+title: "Deployment Guide"
+description: "Deploy locally, to cloud platforms, serverless functions, or container orchestration systems"
+order: 4
+category: deployment
+---
+
+# Deployment Guide
+
+## Overview
+
+This guide covers multiple deployment strategies for the Solana MCP Server, from local development to production serverless deployments and HTTP endpoints.
+
+## Deployment Architecture
+
+```mermaid
+graph TB
+    subgraph "Development"
+        A[Local Binary] --> B[Claude Desktop]
+        A --> C[IDE Integration]
+    end
+    
+    subgraph "HTTP Endpoint"
+        D[HTTP Wrapper] --> E[Load Balancer]
+        E --> F[MCP Server Instance 1]
+        E --> G[MCP Server Instance 2]
+        E --> H[MCP Server Instance N]
+    end
+    
+    subgraph "Serverless"
+        I[API Gateway] --> J[Lambda Function]
+        J --> K[MCP Server Runtime]
+        K --> L[Solana RPC]
+    end
+    
+    subgraph "Container"
+        M[Container Registry] --> N[Kubernetes Pod]
+        M --> O[Docker Compose]
+        M --> P[Cloud Run]
+    end
+    
+    style A fill:#e3f2fd
+    style D fill:#fff3e0
+    style I fill:#f3e5f5
+    style M fill:#e8f5e8
+```
+
+## Local Development
+
+### Quick Start
+```bash
+# Download and configure in one command
+curl -s https://api.github.com/repos/opensvm/solana-mcp-server/releases/latest | \
+grep browser_download_url | grep $(uname -s | tr '[:upper:]' '[:lower:]') | \
+cut -d '"' -f 4 | xargs curl -L -o solana-mcp-server && \
+chmod +x solana-mcp-server && \
+mkdir -p ~/.config/claude && \
+echo '{"mcpServers":{"solana":{"command":"'$(pwd)'/solana-mcp-server","env":{"SOLANA_RPC_URL":"https://api.mainnet-beta.solana.com"}}}}' > ~/.config/claude/config.json
+```
+
+### Manual Configuration
+
+1. **Download Binary**
+```bash
+# Linux
+wget https://github.com/opensvm/solana-mcp-server/releases/latest/download/solana-mcp-server-linux-amd64
+chmod +x solana-mcp-server-linux-amd64
+
+# macOS
+wget https://github.com/opensvm/solana-mcp-server/releases/latest/download/solana-mcp-server-macos-amd64
+chmod +x solana-mcp-server-macos-amd64
+```
+
+2. **Configure Claude Desktop**
+```json
+{
+  "mcpServers": {
+    "solana": {
+      "command": "/path/to/solana-mcp-server",
+      "env": {
+        "SOLANA_RPC_URL": "https://api.mainnet-beta.solana.com",
+        "SOLANA_COMMITMENT": "confirmed"
+      }
+    }
+  }
+}
+```
+
+## HTTP Endpoint Deployment
+
+### Creating HTTP Wrapper
+
+Create a HTTP server that wraps the MCP server:
+
+```rust
+// src/http_server.rs
+use axum::{
+    extract::{Json, State},
+    http::StatusCode,
+    response::Json as ResponseJson,
+    routing::post,
+    Router,
+};
+use serde_json::Value;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+use crate::server::ServerState;
+use crate::tools;
+
+#[derive(Clone)]
+pub struct AppState {
+    pub server_state: Arc<RwLock<ServerState>>,
+}
+
+pub async fn create_app() -> Router {
+    let config = crate::Config::load().unwrap();
+    let server_state = Arc::new(RwLock::new(ServerState::new(config)));
+    let app_state = AppState { server_state };
+    
+    Router::new()
+        .route("/rpc", post(handle_rpc))
+        .route("/health", axum::routing::get(health_check))
+        .with_state(app_state)
+}
+
+async fn handle_rpc(
+    State(state): State<AppState>,
+    Json(payload): Json<Value>,
+) -> Result<ResponseJson<Value>, StatusCode> {
+    match tools::handle_request(&payload.to_string(), state.server_state).await {
+        Ok(response) => Ok(ResponseJson(response)),
+        Err(_) => Err(StatusCode::INTERNAL_SERVER_ERROR),
+    }
+}
+
+async fn health_check() -> &'static str {
+    "OK"
+}
+```
+
+### Docker Configuration
+
+```dockerfile
+# Dockerfile
+FROM rust:1.75 as builder
+
+WORKDIR /app
+COPY . .
+RUN cargo build --release --features http-server
+
+FROM debian:bookworm-slim
+RUN apt-get update && apt-get install -y \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY --from=builder /app/target/release/solana-mcp-server /usr/local/bin/
+EXPOSE 8080
+
+CMD ["solana-mcp-server", "--http", "--port", "8080"]
+```
+
+### Docker Compose
+
+```yaml
+# docker-compose.yml
+version: '3.8'
+services:
+  solana-mcp:
+    build: .
+    ports:
+      - "8080:8080"
+    environment:
+      - SOLANA_RPC_URL=https://api.mainnet-beta.solana.com
+      - SOLANA_COMMITMENT=confirmed
+      - RUST_LOG=info
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+  
+  nginx:
+    image: nginx:alpine
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - ./nginx.conf:/etc/nginx/nginx.conf
+    depends_on:
+      - solana-mcp
+```
+
+### Kubernetes Deployment
+
+```yaml
+# k8s-deployment.yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: solana-mcp-server
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: solana-mcp-server
+  template:
+    metadata:
+      labels:
+        app: solana-mcp-server
+    spec:
+      containers:
+      - name: solana-mcp-server
+        image: solana-mcp-server:latest
+        ports:
+        - containerPort: 8080
+        env:
+        - name: SOLANA_RPC_URL
+          value: "https://api.mainnet-beta.solana.com"
+        resources:
+          requests:
+            memory: "64Mi"
+            cpu: "250m"
+          limits:
+            memory: "128Mi"
+            cpu: "500m"
+        livenessProbe:
+          httpGet:
+            path: /health
+            port: 8080
+          initialDelaySeconds: 30
+          periodSeconds: 10
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: solana-mcp-service
+spec:
+  selector:
+    app: solana-mcp-server
+  ports:
+  - protocol: TCP
+    port: 80
+    targetPort: 8080
+  type: LoadBalancer
+```
+
+## Serverless Deployment
+
+### AWS Lambda
+
+#### Lambda Handler
+```rust
+// src/lambda.rs
+use lambda_runtime::{run, service_fn, Error, LambdaEvent};
+use serde_json::{json, Value};
+use crate::server::ServerState;
+use crate::tools;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+
+async fn function_handler(event: LambdaEvent<Value>) -> Result<Value, Error> {
+    let config = crate::Config::load()?;
+    let state = Arc::new(RwLock::new(ServerState::new(config)));
+    
+    let response = tools::handle_request(
+        &event.payload.to_string(),
+        state
+    ).await?;
+    
+    Ok(response)
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Error> {
+    run(service_fn(function_handler)).await
+}
+```
+
+#### Serverless Framework Configuration
+```yaml
+# serverless.yml
+service: solana-mcp-server
+
+provider:
+  name: aws
+  runtime: provided.al2
+  region: us-east-1
+  timeout: 30
+  memorySize: 256
+  environment:
+    SOLANA_RPC_URL: https://api.mainnet-beta.solana.com
+    RUST_LOG: info
+
+functions:
+  solana-mcp:
+    handler: bootstrap
+    events:
+      - httpApi:
+          path: /rpc
+          method: post
+      - httpApi:
+          path: /health
+          method: get
+
+plugins:
+  - serverless-rust
+
+custom:
+  rust:
+    dockerTag: 'provided.al2'
+```
+
+#### Build Script
+```bash
+#!/bin/bash
+# build-lambda.sh
+
+# Install cargo-lambda if not present
+cargo install cargo-lambda
+
+# Build for Lambda
+cargo lambda build --release
+
+# Package for deployment
+cp target/lambda/solana-mcp-server/bootstrap .
+zip lambda-deployment.zip bootstrap
+
+echo "Lambda package ready: lambda-deployment.zip"
+```
+
+### Google Cloud Functions
+
+```rust
+// src/gcf.rs
+use functions_framework::http::{HttpRequest, HttpResponse};
+use serde_json::Value;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+
+#[functions_framework::http]
+async fn solana_mcp_handler(req: HttpRequest) -> Result<HttpResponse, Box<dyn std::error::Error>> {
+    let body: Value = serde_json::from_slice(&req.into_body())?;
+    
+    let config = crate::Config::load()?;
+    let state = Arc::new(RwLock::new(crate::server::ServerState::new(config)));
+    
+    let response = crate::tools::handle_request(&body.to_string(), state).await?;
+    
+    Ok(HttpResponse::builder()
+        .status(200)
+        .header("content-type", "application/json")
+        .body(serde_json::to_string(&response)?)?)
+}
+```
+
+### Vercel Edge Functions
+
+```rust
+// api/solana-mcp.rs
+use vercel_runtime::{run, Body, Error, Request, Response};
+use serde_json::Value;
+
+#[tokio::main]
+async fn main() -> Result<(), Error> {
+    run(handler).await
+}
+
+pub async fn handler(req: Request) -> Result<Response<Body>, Error> {
+    let body = req.body();
+    let payload: Value = serde_json::from_slice(body)?;
+    
+    // Initialize MCP server state
+    let config = solana_mcp_server::Config::load().map_err(|e| {
+        Error::from(format!("Config error: {}", e))
+    })?;
+    
+    let state = std::sync::Arc::new(tokio::sync::RwLock::new(
+        solana_mcp_server::server::ServerState::new(config)
+    ));
+    
+    let response = solana_mcp_server::tools::handle_request(
+        &payload.to_string(),
+        state
+    ).await.map_err(|e| Error::from(format!("Handler error: {}", e)))?;
+    
+    Ok(Response::builder()
+        .status(200)
+        .header("content-type", "application/json")
+        .body(serde_json::to_string(&response)?.into())?)
+}
+```
+
+## Configuration Management
+
+### Environment-Based Configuration
+
+```bash
+# Production environment variables
+export SOLANA_RPC_URL=https://api.mainnet-beta.solana.com
+export SOLANA_COMMITMENT=confirmed
+export SOLANA_PROTOCOL_VERSION=2024-11-05
+export RUST_LOG=info
+export SERVER_PORT=8080
+export MAX_CONCURRENT_REQUESTS=100
+```
+
+### Configuration File
+
+```json
+{
+  "rpc_url": "https://api.mainnet-beta.solana.com",
+  "commitment": "confirmed",
+  "protocol_version": "2024-11-05",
+  "svm_networks": {
+    "solana-mainnet": {
+      "name": "Solana Mainnet",
+      "rpc_url": "https://api.mainnet-beta.solana.com",
+      "enabled": true
+    },
+    "solana-devnet": {
+      "name": "Solana Devnet",
+      "rpc_url": "https://api.devnet.solana.com",
+      "enabled": false
+    },
+    "eclipse-mainnet": {
+      "name": "Eclipse Mainnet",
+      "rpc_url": "https://mainnetbeta-rpc.eclipse.xyz",
+      "enabled": false
+    }
+  },
+  "server_config": {
+    "port": 8080,
+    "max_concurrent_requests": 100,
+    "request_timeout_ms": 30000,
+    "enable_cors": true,
+    "enable_metrics": true
+  }
+}
+```
+
+## Monitoring and Observability
+
+### Health Checks
+
+```rust
+// Health check endpoint
+async fn health_check(State(state): State<AppState>) -> Result<Json<Value>, StatusCode> {
+    let server_state = state.server_state.read().await;
+    
+    // Check RPC connectivity
+    let health_status = match server_state.rpc_client.get_health().await {
+        Ok(_) => "healthy",
+        Err(_) => "unhealthy",
+    };
+    
+    Ok(Json(json!({
+        "status": health_status,
+        "timestamp": chrono::Utc::now().to_rfc3339(),
+        "version": env!("CARGO_PKG_VERSION"),
+        "enabled_networks": server_state.get_enabled_networks(),
+    })))
+}
+```
+
+### Metrics Collection
+
+```rust
+// Prometheus metrics
+use prometheus::{Counter, Histogram, Gauge, register_counter, register_histogram, register_gauge};
+
+lazy_static! {
+    static ref REQUEST_COUNTER: Counter = register_counter!(
+        "solana_mcp_requests_total",
+        "Total number of RPC requests"
+    ).unwrap();
+    
+    static ref REQUEST_DURATION: Histogram = register_histogram!(
+        "solana_mcp_request_duration_seconds",
+        "Request duration in seconds"
+    ).unwrap();
+    
+    static ref ACTIVE_CONNECTIONS: Gauge = register_gauge!(
+        "solana_mcp_active_connections",
+        "Number of active connections"
+    ).unwrap();
+}
+```
+
+## Performance Tuning
+
+### Resource Optimization
+
+```toml
+# Cargo.toml optimizations
+[profile.release]
+lto = true
+codegen-units = 1
+panic = "abort"
+strip = true
+
+[dependencies]
+tokio = { version = "1.0", features = ["rt-multi-thread", "macros"] }
+```
+
+### Load Testing
+
+```bash
+#!/bin/bash
+# load-test.sh
+
+echo "Load testing Solana MCP Server..."
+
+# Test single RPC call
+ab -n 1000 -c 10 -T application/json -p test_request.json http://localhost:8080/rpc
+
+# Test multi-network calls
+wrk -t12 -c400 -d30s --script=load_test.lua http://localhost:8080/rpc
+```
+
+## Security Considerations
+
+### Production Security Checklist
+
+- [ ] Use HTTPS/TLS in production
+- [ ] Implement rate limiting
+- [ ] Set up request validation
+- [ ] Configure proper CORS policies
+- [ ] Enable request logging
+- [ ] Set up monitoring and alerting
+- [ ] Use secrets management for RPC URLs
+- [ ] Implement circuit breakers for RPC failures
+- [ ] Set up proper error handling and logging
+- [ ] Configure resource limits
\ No newline at end of file
diff --git a/_docs/EXAMPLES.md b/_docs/EXAMPLES.md
new file mode 100644
index 0000000..aa9c602
--- /dev/null
+++ b/_docs/EXAMPLES.md
@@ -0,0 +1,411 @@
+---
+layout: docs
+title: "Examples and Use Cases"
+description: "Real-world examples, use cases, and practical applications with sample queries and responses"
+order: 6
+category: getting_started
+---
+
+# Examples and Use Cases
+
+## Overview
+
+This document provides practical examples of using the Solana MCP Server in various scenarios, from basic queries to advanced multi-network operations.
+
+## Basic Account Operations
+
+### Check Account Balance
+
+**Natural Language:**
+```
+User: "What's the SOL balance of address Gh9ZwEmdLJ8DscKNTkTqPbNwLNNBjuSzaG9Vp2KGtKJr?"
+```
+
+**Direct API Call:**
+```json
+{
+  "method": "tools/call",
+  "params": {
+    "name": "getBalance",
+    "arguments": {
+      "pubkey": "Gh9ZwEmdLJ8DscKNTkTqPbNwLNNBjuSzaG9Vp2KGtKJr"
+    }
+  }
+}
+```
+
+**Response:**
+```json
+{
+  "content": [
+    {
+      "type": "text",
+      "text": "The account has a balance of 2.5 SOL (2,500,000,000 lamports)"
+    }
+  ]
+}
+```
+
+### Get Account Information
+
+**Natural Language:**
+```
+User: "Show me detailed information about account 4fYNw3dojWmQ4dXtSGE9epjRGy9zgEyakSEKvaNdZ54"
+```
+
+**Response includes:**
+- Account balance
+- Owner program
+- Data size
+- Executable status
+- Rent epoch
+
+## Token Operations
+
+### Check Token Balance
+
+**Natural Language:**
+```
+User: "What's the USDC balance in token account 7UX2i7SucgLMQcfZ75s3VXmZZY4YRUyJN9X1Rtf7ckM?"
+```
+
+**Multi-step process:**
+1. Server calls `getTokenAccountBalance`
+2. Identifies token mint and decimals
+3. Returns human-readable balance
+
+### Find Token Accounts by Owner
+
+**Natural Language:**
+```
+User: "Show me all USDC token accounts owned by 9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM"
+```
+
+**Server performs:**
+1. Calls `getTokenAccountsByOwner`
+2. Filters for USDC mint
+3. Returns formatted list with balances
+
+## Block and Transaction Queries
+
+### Current Network Status
+
+**Natural Language:**
+```
+User: "What's the current slot number and latest block hash?"
+```
+
+**Server responds with:**
+- Current slot from `getSlot`
+- Latest blockhash from `getLatestBlockhash`
+- Current epoch information
+
+### Transaction History
+
+**Natural Language:**
+```
+User: "Show me the last 5 transactions for address ABC123..."
+```
+
+**Process:**
+1. `getSignaturesForAddress` with limit=5
+2. For each signature, calls `getTransaction`
+3. Formats transaction details
+
+## Multi-Network Operations
+
+### Network Discovery and Setup
+
+**Step 1: List Available Networks**
+```
+User: "Show me all available SVM networks"
+```
+
+**Response shows:**
+- Solana Mainnet/Devnet
+- Eclipse networks
+- Other SVM-compatible chains
+- Custom network options
+
+**Step 2: Enable Networks**
+```
+User: "Enable Eclipse mainnet for queries"
+```
+
+**Server performs:**
+```json
+{
+  "method": "enableSvmNetwork",
+  "params": {
+    "network_id": "eclipse-mainnet"
+  }
+}
+```
+
+### Cross-Network Comparisons
+
+**Balance Comparison:**
+```
+User: "Check my SOL balance on all enabled networks"
+```
+
+**With networks: solana-mainnet, eclipse-mainnet enabled:**
+```json
+{
+  "solana-mainnet": {
+    "context": {"slot": 123456},
+    "value": 5000000000
+  },
+  "eclipse-mainnet": {
+    "context": {"slot": 98765},
+    "value": 2500000000
+  }
+}
+```
+
+**Formatted Response:**
+```
+Your SOL balance across networks:
+• Solana Mainnet: 5.0 SOL
+• Eclipse Mainnet: 2.5 SOL
+Total: 7.5 SOL equivalent
+```
+
+### Network-Specific Queries
+
+**Custom RPC Configuration:**
+```
+User: "Set a custom RPC URL for development testing"
+```
+
+**Server prompts for:**
+- Network identifier
+- RPC URL
+- Enable/disable status
+
+## Advanced Use Cases
+
+### DeFi Portfolio Analysis
+
+**Natural Language:**
+```
+User: "Analyze the DeFi portfolio for wallet 9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM"
+```
+
+**Multi-step Analysis:**
+1. Get all token accounts owned by wallet
+2. For each token, get current supply and balance
+3. Calculate portfolio distribution
+4. Check for staking accounts
+5. Analyze recent transaction patterns
+
+### Validator Performance Monitoring
+
+**Natural Language:**
+```
+User: "Show me block production stats for validator 7Np41oeYqPefeNQEHSv1UDhYrehxin3NStELsSKCT4K2GRps"
+```
+
+**Server queries:**
+1. `getBlockProduction` for validator
+2. `getVoteAccounts` for stake information
+3. `getLeaderSchedule` for upcoming slots
+
+### Cross-Chain Token Tracking
+
+**Example: USDC across Networks**
+```
+User: "Compare USDC supply and largest holders across all enabled networks"
+```
+
+**Process:**
+1. Identify USDC mint addresses per network
+2. Call `getTokenSupply` on each network
+3. Call `getTokenLargestAccounts` on each
+4. Aggregate and compare results
+
+## Development Workflows
+
+### Smart Contract Testing
+
+**Devnet Account Setup:**
+```
+User: "Request an airdrop of 10 SOL to my test account on devnet"
+```
+
+**Server performs:**
+```json
+{
+  "method": "requestAirdrop",
+  "params": {
+    "pubkey": "test-account-address",
+    "lamports": 10000000000
+  }
+}
+```
+
+### Transaction Simulation
+
+**Pre-flight Testing:**
+```
+User: "Simulate this transaction before sending it"
+```
+
+**Server uses:**
+- `simulateTransaction` for dry-run
+- Returns success/failure and logs
+- Shows account changes and fees
+
+## Integration Examples
+
+### Claude Desktop Integration
+
+**Setup in `~/.config/claude/config.json`:**
+```json
+{
+  "mcpServers": {
+    "solana": {
+      "command": "/path/to/solana-mcp-server",
+      "env": {
+        "SOLANA_RPC_URL": "https://api.mainnet-beta.solana.com",
+        "SOLANA_COMMITMENT": "confirmed"
+      }
+    }
+  }
+}
+```
+
+### Web Application Integration
+
+**HTTP Endpoint Usage:**
+```javascript
+// Query account balance via HTTP
+const response = await fetch('http://localhost:8080/rpc', {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json',
+  },
+  body: JSON.stringify({
+    method: 'tools/call',
+    params: {
+      name: 'getBalance',
+      arguments: {
+        pubkey: 'account-address'
+      }
+    }
+  })
+});
+
+const result = await response.json();
+```
+
+### Serverless Function Integration
+
+**AWS Lambda Handler:**
+```javascript
+export const handler = async (event) => {
+  const query = event.body;
+  
+  // Process through MCP server
+  const response = await mcpServer.handleRequest(query);
+  
+  return {
+    statusCode: 200,
+    body: JSON.stringify(response),
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  };
+};
+```
+
+## Error Handling Examples
+
+### Network Connectivity Issues
+
+**When RPC is down:**
+```json
+{
+  "error": {
+    "code": -32603,
+    "message": "RPC endpoint unavailable",
+    "data": {
+      "network": "solana-mainnet",
+      "url": "https://api.mainnet-beta.solana.com",
+      "fallback_available": true
+    }
+  }
+}
+```
+
+### Invalid Parameters
+
+**Invalid address format:**
+```json
+{
+  "error": {
+    "code": -32602,
+    "message": "Invalid pubkey format",
+    "data": {
+      "provided": "invalid-address",
+      "expected": "base58-encoded string"
+    }
+  }
+}
+```
+
+## Performance Examples
+
+### Batch Operations
+
+**Multiple Account Queries:**
+```
+User: "Check balances for these 10 accounts: [list of addresses]"
+```
+
+**Server optimizes with:**
+- `getMultipleAccounts` for batch processing
+- Parallel requests across networks
+- Response aggregation
+
+### Caching Scenarios
+
+**Repeated Network Info Queries:**
+- Network list cached for 1 hour
+- Block height cached for 30 seconds
+- Account info cached for configurable duration
+
+## Monitoring and Debugging
+
+### Health Check Examples
+
+**Server Health:**
+```bash
+curl http://localhost:8080/health
+```
+
+**Response:**
+```json
+{
+  "status": "healthy",
+  "timestamp": "2024-01-15T10:30:00Z",
+  "version": "1.0.0",
+  "enabled_networks": ["solana-mainnet", "eclipse-mainnet"],
+  "rpc_status": {
+    "solana-mainnet": "connected",
+    "eclipse-mainnet": "connected"
+  }
+}
+```
+
+### Performance Metrics
+
+**Request Timing:**
+```
+2024-01-15 10:30:00 [INFO] Request processed in 150ms
+  - Network routing: 5ms
+  - RPC calls: 120ms (parallel)
+  - Response formatting: 25ms
+```
+
+This comprehensive examples guide demonstrates the full capabilities of the Solana MCP Server across various use cases and integration scenarios.
\ No newline at end of file
diff --git a/_docs/ONBOARDING.md b/_docs/ONBOARDING.md
new file mode 100644
index 0000000..aa35e08
--- /dev/null
+++ b/_docs/ONBOARDING.md
@@ -0,0 +1,592 @@
+---
+layout: docs
+title: "Developer Onboarding Guide"
+description: "Get up and running as a contributor quickly and confidently with this comprehensive guide"
+order: 1
+category: getting_started
+---
+
+# Developer Onboarding Guide
+
+Welcome to the Solana MCP Server project! This guide will help you get up and running as a contributor quickly and confidently. Whether you're new to Rust, Solana, or MCP (Model Context Protocol), this step-by-step walkthrough will guide you through the entire development lifecycle.
+
+## 🚀 Quick Start
+
+If you're already familiar with Rust development, here's the fast track:
+
+```bash
+# Clone and setup
+git clone https://github.com/opensvm/solana-mcp-server.git
+cd solana-mcp-server
+
+# Build and test
+cargo build
+cargo test
+
+# Run the server
+cargo run
+```
+
+For a detailed walkthrough, continue reading below.
+
+## 📋 Table of Contents
+
+1. [Project Overview](#project-overview)
+2. [Prerequisites](#prerequisites)
+3. [Environment Setup](#environment-setup)
+4. [Building the Project](#building-the-project)
+5. [Running Tests](#running-tests)
+6. [Running the Server](#running-the-server)
+7. [Debugging](#debugging)
+8. [Deployment](#deployment)
+9. [Contributing](#contributing)
+10. [Troubleshooting](#troubleshooting)
+11. [Resources](#resources)
+
+## 🎯 Project Overview
+
+The Solana MCP Server is a **Model Context Protocol (MCP) implementation** that provides AI assistants (like Claude) with comprehensive access to Solana blockchain data. It acts as a bridge between AI systems and the Solana ecosystem.
+
+### Key Components
+
+- **MCP Server**: Implements the Model Context Protocol specification
+- **RPC Methods**: 40+ Solana RPC methods for blockchain data access
+- **Multi-Network Support**: Mainnet, Devnet, Testnet, and Eclipse networks
+- **Flexible Deployment**: Local, Docker, serverless, and Kubernetes options
+
+### Architecture at a Glance
+
+```
+AI Assistant (Claude) → MCP Protocol → Solana MCP Server → Solana RPC → Blockchain
+```
+
+For detailed architecture information, see [docs/ARCHITECTURE.md](./ARCHITECTURE.md).
+
+## 📚 Prerequisites
+
+Before starting, ensure you have:
+
+- **Basic familiarity with**:
+  - Command line/terminal usage
+  - Git version control
+  - Basic programming concepts
+- **Helpful but not required**:
+  - Rust programming language
+  - Blockchain/Solana concepts
+  - JSON-RPC protocols
+
+## 🛠️ Environment Setup
+
+### 1. Install Rust
+
+The project requires Rust 1.75 or later.
+
+```bash
+# Install Rust via rustup (recommended)
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+
+# Follow the prompts, then reload your shell
+source ~/.cargo/env
+
+# Verify installation
+rustc --version
+cargo --version
+```
+
+### 2. Install Development Tools
+
+```bash
+# Install essential tools
+cargo install cargo-watch    # For auto-rebuilding during development
+cargo install cargo-expand   # For macro debugging (optional)
+
+# For better debugging experience
+rustup component add rust-src
+rustup component add llvm-tools-preview
+```
+
+### 3. IDE Setup
+
+**VS Code (Recommended)**:
+```bash
+# Install VS Code extensions
+code --install-extension rust-lang.rust-analyzer
+code --install-extension serayuzgur.crates
+code --install-extension vadimcn.vscode-lldb  # For debugging
+```
+
+**Other IDEs**:
+- **IntelliJ IDEA**: Install the Rust plugin
+- **Vim/Neovim**: Use rust-analyzer LSP
+- **Emacs**: Use rust-mode with lsp-mode
+
+### 4. Clone the Repository
+
+```bash
+git clone https://github.com/opensvm/solana-mcp-server.git
+cd solana-mcp-server
+```
+
+### 5. Verify Environment
+
+```bash
+# Check Rust version
+rustc --version
+# Should show: rustc 1.75.0 or later
+
+# Check project structure
+ls -la
+# Should show: Cargo.toml, src/, docs/, tests/, etc.
+```
+
+## 🔨 Building the Project
+
+### 1. Understanding the Build System
+
+The project uses **Cargo**, Rust's build system and package manager. Key files:
+
+- `Cargo.toml`: Project configuration and dependencies
+- `Cargo.lock`: Dependency versions (committed to Git)
+- `src/`: Source code directory
+- `tests/`: Integration tests
+
+### 2. Building for Development
+
+```bash
+# Build in debug mode (faster compilation, slower execution)
+cargo build
+
+# Build with optimizations (slower compilation, faster execution)
+cargo build --release
+
+# Check code without building (fastest)
+cargo check
+```
+
+### 3. Understanding Build Output
+
+```bash
+# After building, you'll see:
+ls -la target/debug/
+# solana-mcp-server    # The main executable
+# deps/                # Compiled dependencies
+# build/               # Build artifacts
+```
+
+### 4. Continuous Building
+
+For development, use `cargo-watch` to automatically rebuild on file changes:
+
+```bash
+# Auto-rebuild on changes
+cargo watch -x build
+
+# Auto-rebuild and run tests
+cargo watch -x test
+
+# Auto-rebuild and run the server
+cargo watch -x run
+```
+
+## 🧪 Running Tests
+
+### 1. Test Structure
+
+The project has several types of tests:
+
+- **Unit Tests**: In `src/` files using `#[cfg(test)]`
+- **Integration Tests**: In `tests/` directory
+- **Documentation Tests**: In doc comments (using `///`)
+
+### 2. Running Tests
+
+```bash
+# Run all tests
+cargo test
+
+# Run specific test
+cargo test test_name
+
+# Run tests with output
+cargo test -- --nocapture
+
+# Run only unit tests
+cargo test --lib
+
+# Run only integration tests
+cargo test --test '*'
+
+# Run tests in specific file
+cargo test --test validation
+```
+
+### 3. Understanding Test Output
+
+```bash
+# Successful test run shows:
+running 9 tests
+test protocol::tests::test_server_capabilities ... ok
+test validation::tests::test_validate_commitment ... ok
+# ... more tests ...
+test result: ok. 9 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
+```
+
+### 4. Writing Tests
+
+When contributing, add tests for new functionality:
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_my_function() {
+        assert_eq!(my_function(5), 10);
+    }
+}
+```
+
+## 🚀 Running the Server
+
+### 1. Configuration
+
+The server can be configured via:
+
+- **Environment variables** (recommended for development)
+- **Configuration file** (`config.json`)
+- **Command line arguments**
+
+### 2. Basic Local Run
+
+```bash
+# Run with default configuration
+cargo run
+
+# Run with custom RPC endpoint
+SOLANA_RPC_URL=https://api.devnet.solana.com cargo run
+
+# Run with debug logging
+RUST_LOG=debug cargo run
+
+# Run with specific configuration file
+cargo run -- --config config.json
+```
+
+### 3. Environment Variables
+
+Key environment variables for development:
+
+```bash
+# Set Solana RPC endpoint
+export SOLANA_RPC_URL="https://api.devnet.solana.com"
+
+# Set commitment level (processed|confirmed|finalized)
+export SOLANA_COMMITMENT="confirmed"
+
+# Enable debug logging
+export RUST_LOG="debug"
+
+# Set protocol version
+export SOLANA_PROTOCOL_VERSION="2024-11-05"
+```
+
+### 4. Verifying the Server
+
+Once running, the server will:
+
+1. **Initialize**: Load configuration and validate settings
+2. **Connect**: Establish RPC connections to Solana networks
+3. **Listen**: Wait for MCP protocol connections
+4. **Log**: Output status information
+
+Look for log messages like:
+```
+[INFO] Solana MCP Server starting
+[INFO] Connected to Solana RPC: https://api.devnet.solana.com
+[INFO] Server ready to accept connections
+```
+
+## 🐛 Debugging
+
+### 1. Logging
+
+Use environment variables to control logging:
+
+```bash
+# Debug level logging
+RUST_LOG=debug cargo run
+
+# Module-specific logging
+RUST_LOG=solana_mcp_server=debug cargo run
+
+# Multiple modules
+RUST_LOG=solana_mcp_server=debug,reqwest=info cargo run
+```
+
+### 2. Debugging Tools
+
+**LLDB (recommended for macOS/Linux)**:
+```bash
+# Install LLDB
+rustup component add llvm-tools-preview
+
+# Debug with LLDB
+rust-lldb target/debug/solana-mcp-server
+# (lldb) run
+# (lldb) bt  # backtrace
+# (lldb) p variable_name  # print variable
+```
+
+**GDB (Linux)**:
+```bash
+# Debug with GDB
+rust-gdb target/debug/solana-mcp-server
+# (gdb) run
+# (gdb) bt  # backtrace
+# (gdb) p variable_name  # print variable
+```
+
+### 3. IDE Debugging
+
+**VS Code**: Use the CodeLLDB extension:
+1. Install the `vadimcn.vscode-lldb` extension
+2. Add debug configuration in `.vscode/launch.json`
+3. Set breakpoints and press F5
+
+### 4. Common Debugging Scenarios
+
+**Connection Issues**:
+```bash
+# Test RPC connectivity
+curl -X POST -H "Content-Type: application/json" \
+  --data '{"jsonrpc":"2.0","id":1,"method":"getHealth"}' \
+  https://api.devnet.solana.com
+
+# Check network connectivity
+ping api.devnet.solana.com
+```
+
+**Performance Issues**:
+```bash
+# Profile with flamegraph
+cargo install flamegraph
+sudo flamegraph target/debug/solana-mcp-server
+
+# Memory usage
+valgrind --tool=massif target/debug/solana-mcp-server
+```
+
+## 🚢 Deployment
+
+### 1. Deployment Options
+
+The project supports multiple deployment methods:
+
+- **Local Binary**: Direct execution
+- **Docker**: Containerized deployment
+- **Kubernetes**: Orchestrated containers
+- **Serverless**: AWS Lambda, Google Cloud Functions, Vercel
+
+### 2. Local Deployment
+
+```bash
+# Build release version
+cargo build --release
+
+# Run release version
+./target/release/solana-mcp-server
+
+# Or use the deployment script
+./scripts/deploy-local.sh
+```
+
+### 3. Docker Deployment
+
+```bash
+# Build Docker image
+docker build -t solana-mcp-server .
+
+# Run container
+docker run -p 8080:8080 \
+  -e SOLANA_RPC_URL=https://api.mainnet-beta.solana.com \
+  solana-mcp-server
+
+# Or use the deployment script
+./scripts/deploy-docker.sh
+```
+
+### 4. Other Deployment Options
+
+See the [Deployment Guide](./DEPLOYMENT.md) for detailed instructions on:
+
+- **Kubernetes**: `./scripts/deploy-k8s.sh`
+- **AWS Lambda**: `./scripts/deploy-lambda.sh`
+- **Google Cloud Functions**: `./scripts/deploy-gcf.sh`
+- **Vercel**: `./scripts/deploy-vercel.sh`
+
+## 🤝 Contributing
+
+### 1. Development Workflow
+
+```bash
+# 1. Create a feature branch
+git checkout -b feature/my-new-feature
+
+# 2. Make changes and test
+cargo test
+cargo build
+
+# 3. Commit changes
+git add .
+git commit -m "Add new feature: description"
+
+# 4. Push and create PR
+git push origin feature/my-new-feature
+```
+
+### 2. Code Style
+
+The project follows standard Rust conventions:
+
+```bash
+# Format code
+cargo fmt
+
+# Check for common issues
+cargo clippy
+
+# Check for security issues
+cargo audit  # (requires: cargo install cargo-audit)
+```
+
+### 3. Submitting Changes
+
+1. **Fork** the repository
+2. **Create** a feature branch
+3. **Make** your changes
+4. **Test** thoroughly
+5. **Submit** a pull request
+
+### 4. PR Checklist
+
+Before submitting a PR:
+
+- [ ] Code builds without warnings
+- [ ] All tests pass
+- [ ] New tests added for new functionality
+- [ ] Code is formatted (`cargo fmt`)
+- [ ] No clippy warnings (`cargo clippy`)
+- [ ] Documentation updated if needed
+- [ ] Commit messages are descriptive
+
+## 🔧 Troubleshooting
+
+### Common Issues
+
+**Build Fails with "linker not found"**:
+```bash
+# Install build tools
+# Ubuntu/Debian:
+sudo apt install build-essential
+
+# macOS:
+xcode-select --install
+
+# Windows:
+# Install Visual Studio Build Tools
+```
+
+**Tests Fail with Network Errors**:
+```bash
+# Check internet connection
+ping api.devnet.solana.com
+
+# Use local test validator (requires Solana CLI)
+solana-test-validator
+
+# Set test RPC to local validator
+export SOLANA_RPC_URL="http://localhost:8899"
+```
+
+**Cargo Build is Slow**:
+```bash
+# Use cargo-cache to clean old builds
+cargo install cargo-cache
+cargo cache --autoclean
+
+# Use more parallel jobs
+cargo build -j 8
+```
+
+**Clippy Warnings**:
+```bash
+# Current codebase has some clippy warnings that are non-critical
+# You can run clippy to see them:
+cargo clippy
+
+# To ignore existing warnings while working:
+cargo clippy --all-targets --all-features
+```
+
+**IDE Not Recognizing Code**:
+```bash
+# Regenerate IDE files
+cargo clean
+cargo build
+
+# Update rust-analyzer
+rustup update
+```
+
+### Getting Help
+
+1. **Check existing issues**: [GitHub Issues](https://github.com/opensvm/solana-mcp-server/issues)
+2. **Search documentation**: Use the search in GitHub
+3. **Ask questions**: Open a new issue with the "question" label
+4. **Join discussions**: [GitHub Discussions](https://github.com/opensvm/solana-mcp-server/discussions)
+
+## 📖 Resources
+
+### Documentation
+
+- [Architecture Overview](./ARCHITECTURE.md) - System design and components
+- [API Reference](./API_REFERENCE.md) - Complete RPC method documentation
+- [Configuration Guide](./CONFIGURATION.md) - Configuration options and management
+- [Deployment Guide](./DEPLOYMENT.md) - Production deployment instructions
+- [Examples](./EXAMPLES.md) - Practical usage examples
+
+### Rust Learning Resources
+
+- [The Rust Programming Language](https://doc.rust-lang.org/book/) - Official Rust book
+- [Rust by Example](https://doc.rust-lang.org/rust-by-example/) - Learn by examples
+- [Rustlings](https://github.com/rust-lang/rustlings) - Interactive exercises
+- [Cargo Book](https://doc.rust-lang.org/cargo/) - Cargo documentation
+
+### Solana Resources
+
+- [Solana Documentation](https://docs.solana.com/) - Official Solana docs
+- [Solana Cookbook](https://solanacookbook.com/) - Developer recipes
+- [Solana RPC API](https://docs.solana.com/api/http) - RPC method reference
+
+### Model Context Protocol
+
+- [MCP Specification](https://modelcontextprotocol.io/docs/specification) - Protocol specification
+- [MCP SDK](https://github.com/modelcontextprotocol/sdk) - Official SDK
+- [MCP Examples](https://github.com/modelcontextprotocol/examples) - Example implementations
+
+## 🎉 Next Steps
+
+Congratulations! You now have a solid foundation for contributing to the Solana MCP Server. Here's what you can do next:
+
+1. **Explore the codebase**: Start with `src/main.rs` and `src/lib.rs`
+2. **Try making small changes**: Add a log message or modify a test
+3. **Read the detailed docs**: Dive deeper into [ARCHITECTURE.md](./ARCHITECTURE.md)
+4. **Pick up an issue**: Look for "good first issue" labels
+5. **Join the community**: Participate in discussions and help others
+
+Welcome to the team! 🚀
+
+---
+
+*This guide is maintained by the community. If you find issues or have suggestions for improvements, please [open an issue](https://github.com/opensvm/solana-mcp-server/issues/new) or submit a PR.*
\ No newline at end of file
diff --git a/_docs/README.md b/_docs/README.md
new file mode 100644
index 0000000..864f060
--- /dev/null
+++ b/_docs/README.md
@@ -0,0 +1,230 @@
+# Solana MCP Server Documentation
+
+## Table of Contents
+
+1. [Developer Onboarding Guide](./ONBOARDING.md) - **New contributors start here!**
+2. [Architecture Overview](./ARCHITECTURE.md)
+3. [Deployment Guide](./DEPLOYMENT.md)
+4. [API Reference](./API_REFERENCE.md)
+5. [Configuration Guide](./CONFIGURATION.md)
+6. [Examples and Use Cases](./EXAMPLES.md)
+
+## Quick Overview
+
+The Solana MCP Server is a comprehensive Model Context Protocol implementation that provides seamless access to Solana blockchain data through AI assistants like Claude. It features multi-network support, extensive RPC method coverage, and flexible deployment options.
+
+## Key Features
+
+### 🚀 Comprehensive RPC Coverage
+- **47 Solana RPC methods** across all major categories
+- **4 network management methods** for multi-SVM support
+- **Real-time blockchain data** with configurable commitment levels
+
+### 🌐 Multi-Network Support
+- Query multiple SVM-compatible networks simultaneously
+- Dynamic network configuration and management
+- Parallel execution with result aggregation
+
+### 🛠️ Flexible Deployment
+- Local development with Claude Desktop
+- HTTP endpoint deployment
+- Serverless functions (AWS Lambda, Vercel, Google Cloud)
+- Container orchestration (Docker, Kubernetes)
+
+### ⚡ High Performance
+- Connection pooling and persistent RPC clients
+- Configurable caching layers
+- Parallel multi-network queries
+- Built-in rate limiting and error recovery
+
+## Architecture Overview
+
+```mermaid
+graph TB
+    subgraph "AI Assistant"
+        A[Claude Desktop] --> B[Natural Language Query]
+    end
+    
+    subgraph "MCP Protocol Layer"
+        B --> C[MCP Client]
+        C --> D[JSON-RPC 2.0]
+    end
+    
+    subgraph "Solana MCP Server"
+        D --> E[Request Handler]
+        E --> F[Tool Dispatcher]
+        F --> G[Multi-Network Router]
+        G --> H[RPC Client Pool]
+    end
+    
+    subgraph "Configuration"
+        I[config.json] --> F
+        J[Environment Variables] --> F
+        K[SVM Networks Registry] --> G
+    end
+    
+    subgraph "Blockchain Networks"
+        H --> L[Solana Mainnet]
+        H --> M[Solana Devnet]
+        H --> N[Eclipse Network]
+        H --> O[Custom Networks]
+    end
+    
+    style A fill:#e1f5fe
+    style E fill:#fff3e0
+    style G fill:#f3e5f5
+    style L fill:#ffebee
+```
+
+## Getting Started
+
+### 1. Quick Installation
+```bash
+# Download and configure automatically
+curl -s https://api.github.com/repos/opensvm/solana-mcp-server/releases/latest | \
+grep browser_download_url | grep $(uname -s | tr '[:upper:]' '[:lower:]') | \
+cut -d '"' -f 4 | xargs curl -L -o solana-mcp-server && \
+chmod +x solana-mcp-server && \
+mkdir -p ~/.config/claude && \
+echo '{"mcpServers":{"solana":{"command":"'$(pwd)'/solana-mcp-server","env":{"SOLANA_RPC_URL":"https://api.mainnet-beta.solana.com"}}}}' > ~/.config/claude/config.json
+```
+
+### 2. Basic Usage
+Once configured, you can interact through natural language:
+
+- "What's the SOL balance of address `Gh9ZwEmdLJ8DscKNTkTqPbNwLNNBjuSzaG9Vp2KGtKJr`?"
+- "Show me the current slot number"
+- "Get the token supply for USDC"
+- "List all available SVM networks"
+
+### 3. Multi-Network Setup
+```bash
+# Enable additional networks
+"Enable Eclipse mainnet network"
+"Set a custom RPC URL for development testing"
+```
+
+## Documentation Structure
+
+### [Architecture Overview](./ARCHITECTURE.md)
+Comprehensive guide to the server's internal architecture, components, and data flow patterns.
+
+**Topics Covered:**
+- System architecture diagrams
+- Core component interactions
+- Request/response flow
+- Multi-network routing
+- Security model
+- Performance characteristics
+
+### [Deployment Guide](./DEPLOYMENT.md)
+Step-by-step instructions for deploying the server in various environments.
+
+**Deployment Options:**
+- Local development setup
+- HTTP endpoint deployment
+- Serverless functions (AWS Lambda, Vercel, Google Cloud)
+- Container orchestration
+- Production configuration
+- Monitoring and observability
+
+### [API Reference](./API_REFERENCE.md)
+Complete documentation of all available RPC methods and network management features.
+
+**Method Categories:**
+- Network Management (4 methods)
+- Account Methods (6 methods)
+- Block Methods (9 methods)
+- System Methods (6 methods)
+- Epoch and Inflation Methods (5 methods)
+- Token Methods (5 methods)
+- Transaction Methods (6 methods)
+- Other Methods (6 methods)
+
+### [Configuration Guide](./CONFIGURATION.md)
+Detailed configuration options, formats, and best practices.
+
+**Configuration Topics:**
+- Configuration file formats
+- Environment variables
+- Network management
+- Security settings
+- Performance tuning
+- Development vs production configs
+
+### [Examples and Use Cases](./EXAMPLES.md)
+Practical examples and real-world use cases for the Solana MCP Server.
+
+**Example Categories:**
+- Basic account and token operations
+- Multi-network queries and comparisons
+- DeFi portfolio analysis
+- Development workflows
+- Integration patterns
+- Error handling scenarios
+
+## Network Support
+
+The server supports querying multiple SVM-compatible networks:
+
+| Network | Status | Default RPC |
+|---------|--------|-------------|
+| Solana Mainnet | ✅ Supported | api.mainnet-beta.solana.com |
+| Solana Devnet | ✅ Supported | api.devnet.solana.com |
+| Eclipse Mainnet | ✅ Supported | mainnetbeta-rpc.eclipse.xyz |
+| Custom Networks | ✅ Supported | User-configurable |
+
+## Request Flow
+
+```mermaid
+sequenceDiagram
+    participant U as User
+    participant C as Claude
+    participant M as MCP Server
+    participant S as Solana RPC
+    participant E as Eclipse RPC
+    
+    U->>C: "Get balance on all networks"
+    C->>M: tools/call: getBalance
+    M->>M: Check enabled networks
+    
+    par Parallel Network Queries
+        M->>S: getBalance RPC
+        M->>E: getBalance RPC
+    end
+    
+    S-->>M: Solana balance
+    E-->>M: Eclipse balance
+    M->>M: Aggregate results
+    M-->>C: Multi-network response
+    C-->>U: "Balance on Solana: 1.5 SOL, Eclipse: 0.8 SOL"
+```
+
+## Performance Metrics
+
+| Metric | Single Network | Multi-Network |
+|--------|---------------|---------------|
+| Latency | 100-500ms | 200-800ms |
+| Throughput | 100 req/min | 50 req/min |
+| Memory Usage | ~10MB | ~15MB |
+| CPU Usage | Minimal | Low |
+
+## Contributing
+
+We welcome contributions! Please see our contributing guidelines for:
+- Code style and standards
+- Testing requirements
+- Documentation updates
+- Feature requests and bug reports
+
+## Support
+
+For support and questions:
+- 📖 Documentation: This documentation set
+- 🐛 Issues: GitHub Issues
+- 💬 Discussions: GitHub Discussions
+- 📧 Contact: [Maintainer contact information]
+
+## License
+
+This project is licensed under the MIT License. See the LICENSE file for details.
\ No newline at end of file
diff --git a/_docs/benchmarks.md b/_docs/benchmarks.md
new file mode 100644
index 0000000..6798f49
--- /dev/null
+++ b/_docs/benchmarks.md
@@ -0,0 +1,157 @@
+# Benchmark Tests
+
+This directory contains comprehensive performance benchmarks for the Solana MCP Server.
+
+## Overview
+
+The benchmarks measure performance across three key areas:
+
+### 1. HTTP API Benchmarks (`http_api_bench.rs`)
+- **MCP Protocol Performance**: Initialization, tools list, protocol compliance
+- **RPC Tool Calls**: Individual method call latency and throughput
+- **Concurrent Requests**: Multi-client performance under load
+- **Endpoint Performance**: Health and metrics endpoint response times
+
+### 2. RPC Methods Benchmarks (`rpc_methods_bench.rs`)
+- **System Methods**: Core blockchain queries (getHealth, getVersion, etc.)
+- **Account Methods**: Balance and account information retrieval
+- **Block/Transaction Methods**: Blockchain data access performance
+- **Token Methods**: SPL token operations
+- **Error Handling**: Invalid request processing efficiency
+
+### 3. WebSocket Benchmarks (`websocket_bench.rs`)
+- **Connection Management**: WebSocket establishment and teardown
+- **Subscription Operations**: Real-time data subscription performance
+- **Message Throughput**: High-frequency message handling
+- **Concurrent Connections**: Multi-client WebSocket performance
+- **Error Recovery**: Invalid request and connection error handling
+
+## Running Benchmarks
+
+### Local Execution
+
+```bash
+# Run all benchmarks
+cargo bench
+
+# Run specific benchmark suite
+cargo bench --bench http_api_bench
+cargo bench --bench rpc_methods_bench  
+cargo bench --bench websocket_bench
+
+# Generate HTML reports
+cargo bench -- --output-format html
+```
+
+### Quick Test
+```bash
+# Test benchmark compilation and basic execution
+./test-benchmarks.sh
+```
+
+## GitHub Actions Integration
+
+The benchmarks are automatically executed via GitHub Actions:
+
+- **Triggers**: Push to main/develop, PRs, daily schedule, manual dispatch
+- **Platforms**: Ubuntu latest with full Rust toolchain
+- **Artifacts**: HTML reports, detailed metrics, performance analysis
+- **PR Integration**: Automatic benchmark result comments
+
+### Workflow Features
+
+1. **Comprehensive Execution**: All three benchmark suites
+2. **HTML Report Generation**: Interactive charts and detailed analysis
+3. **Artifact Storage**: 30-day retention of benchmark results
+4. **Performance Analysis**: Regression detection and recommendations
+5. **PR Comments**: Automatic benchmark summary on pull requests
+
+## Benchmark Results
+
+### Artifacts Generated
+
+- `benchmark-reports-{run-id}`: Summary and analysis files
+- `criterion-detailed-reports-{run-id}`: Interactive HTML reports
+- `performance-comparison-{run-id}`: PR performance comparison
+
+### Report Structure
+
+```
+benchmark-results/
+├── README.md                      # Benchmark overview
+├── benchmark-summary.txt          # Text summary
+├── system-info.txt               # System information
+├── performance-analysis.md       # Performance analysis
+├── http-api-criterion-reports/   # HTTP API detailed reports
+├── rpc-methods-criterion-reports/ # RPC methods detailed reports
+└── websocket-criterion-reports/  # WebSocket detailed reports
+```
+
+## Performance Targets
+
+### Response Time Targets
+- Simple RPC calls: < 50ms
+- Account queries: < 100ms  
+- Block/transaction queries: < 200ms
+- WebSocket connections: < 100ms
+
+### Throughput Targets
+- Concurrent HTTP requests: > 100 req/s
+- WebSocket connections: > 50 concurrent
+- Message throughput: > 1000 msg/s
+
+## Benchmark Configuration
+
+### Test Environment
+- **Ports**: 9001-9003 (dedicated benchmark ports)
+- **Duration**: Criterion default with HTML output
+- **Concurrency**: 1, 5, 10, 20 concurrent clients tested
+- **Network**: Local loopback for consistent results
+
+### Error Handling
+- Network timeouts handled gracefully
+- Invalid parameter testing included  
+- Connection failure recovery tested
+- Real Solana RPC integration (may timeout in CI)
+
+## Development
+
+### Adding New Benchmarks
+
+1. **Identify Performance-Critical Code**: Focus on hot paths
+2. **Create Benchmark Function**: Follow Criterion patterns
+3. **Add to Benchmark Group**: Include in appropriate suite
+4. **Update Documentation**: Document new benchmark purpose
+5. **Test Locally**: Verify benchmark executes successfully
+
+### Best Practices
+
+- Use `black_box()` to prevent compiler optimizations
+- Test realistic scenarios and data sizes
+- Include both success and error path benchmarks
+- Use separate ports to avoid test conflicts
+- Document performance expectations and targets
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Port Conflicts**: Benchmarks use dedicated ports 9001-9003
+2. **Network Timeouts**: Some tests make real Solana RPC calls
+3. **Resource Limits**: Large concurrent tests may hit system limits
+4. **Build Dependencies**: Requires OpenSSL and standard build tools
+
+### CI-Specific Considerations
+
+- Ubuntu system dependencies installed automatically
+- Benchmarks continue on error for partial results
+- HTML reports generated even if some benchmarks fail
+- Network restrictions may affect external RPC calls
+
+## Future Enhancements
+
+- **Historical Tracking**: Compare benchmark results over time  
+- **Regression Alerts**: Automated alerts for performance degradation
+- **Load Testing**: Extended duration and stress testing
+- **Memory Profiling**: Memory usage and leak detection
+- **Real Network Testing**: Against actual Solana clusters
\ No newline at end of file
diff --git a/_docs/developer/error_handling.md b/_docs/developer/error_handling.md
new file mode 100644
index 0000000..cf2ebb1
--- /dev/null
+++ b/_docs/developer/error_handling.md
@@ -0,0 +1,156 @@
+# Error Handling and Logging Guidelines
+
+## Overview
+
+This document describes the robust error handling and logging patterns implemented in the Solana MCP Server.
+
+## Error Handling Architecture
+
+### Error Types
+
+The server uses a centralized error hierarchy defined in `src/error.rs`:
+
+- **`McpError::Client`** - Client-side errors (invalid input, malformed requests)
+- **`McpError::Server`** - Server-side errors (internal failures, service unavailable)
+- **`McpError::Rpc`** - RPC-specific errors (Solana client failures)
+- **`McpError::Validation`** - Validation errors (invalid parameters, security checks)
+- **`McpError::Network`** - Network errors (connectivity issues, timeouts)
+- **`McpError::Auth`** - Authentication/Authorization errors
+
+### Error Context
+
+All errors include contextual information:
+- Request ID for tracing
+- Method name being executed
+- Relevant parameters (sanitized)
+- Source error information
+
+### Error Usage Pattern
+
+```rust
+use crate::error::{McpError, McpResult};
+
+pub async fn example_rpc_call(client: &RpcClient, param: &str) -> McpResult<Value> {
+    let request_id = new_request_id();
+    let start_time = Instant::now();
+    let method = "exampleCall";
+    
+    // Log request start
+    log_rpc_request_start(request_id, method, Some(&client.url()), Some("param info"));
+
+    match client.some_rpc_call(param).await {
+        Ok(result) => {
+            let duration = start_time.elapsed().as_millis() as u64;
+            log_rpc_request_success(request_id, method, duration, Some("success message"));
+            Ok(serde_json::json!({ "result": result }))
+        }
+        Err(e) => {
+            let duration = start_time.elapsed().as_millis() as u64;
+            let error = McpError::from(e)
+                .with_request_id(request_id)
+                .with_method(method)
+                .with_rpc_url(&client.url());
+            
+            log_rpc_request_failure(request_id, method, error.error_type(), duration, Some(&error.to_log_value()));
+            Err(error)
+        }
+    }
+}
+```
+
+## Logging Architecture
+
+### Structured Logging
+
+The server uses `tracing` with JSON output for structured logging:
+
+- All logs include timestamps, levels, and contextual metadata
+- Sensitive data is automatically sanitized
+- Request IDs enable distributed tracing
+- Performance metrics are captured
+
+### Log Levels
+
+- **ERROR** - RPC failures, server errors, critical issues
+- **WARN** - Validation failures, recoverable errors
+- **INFO** - Successful operations, server lifecycle events
+- **DEBUG** - Detailed debugging information (testing only)
+
+### Metrics Collection
+
+The logging system automatically collects metrics:
+
+- Total RPC calls
+- Successful RPC calls
+- Failed calls by error type
+- Failed calls by method
+- Request duration timing
+
+Access metrics via `get_metrics().to_json()`.
+
+## Security Considerations
+
+### Data Sanitization
+
+- URLs are sanitized to hide sensitive paths/parameters
+- Long strings are truncated to prevent log flooding
+- Parameter values are summarized, not logged in full
+- Error messages distinguish between safe and internal errors
+
+### Safe Error Messages
+
+Client-facing error messages use `error.safe_message()` which:
+- Shows validation errors to help with debugging
+- Hides internal server errors to prevent information leakage
+- Returns generic messages for auth errors
+
+## Implementation Status
+
+### Completed
+- ✅ Error type hierarchy and context
+- ✅ Structured logging with tracing
+- ✅ Metrics collection
+- ✅ Accounts RPC module
+- ✅ System RPC module (partially)
+
+### Remaining Work
+- [ ] Complete system RPC module error handling
+- [ ] Update blocks RPC module
+- [ ] Update tokens RPC module
+- [ ] Update transactions RPC module
+- [ ] Integration tests for error scenarios
+
+## Testing
+
+Run error handling tests:
+```bash
+cargo test error::tests
+cargo test logging::tests
+```
+
+## Configuration
+
+Initialize logging in `main.rs`:
+```rust
+use solana_mcp_server::init_logging;
+
+if let Err(e) = init_logging(Some("info")) {
+    eprintln!("Failed to initialize logging: {}", e);
+    std::process::exit(1);
+}
+```
+
+Set log level via environment variable:
+```bash
+RUST_LOG=debug cargo run
+```
+
+## Best Practices
+
+1. **Always use McpResult<T>** for RPC functions
+2. **Include request IDs** for tracing correlation
+3. **Log request start/success/failure** for all RPC calls
+4. **Provide meaningful error context** using error builders
+5. **Sanitize sensitive data** before logging
+6. **Use appropriate error types** for categorization
+7. **Test error handling paths** in integration tests
diff --git a/_docs/docker-scaling.md b/_docs/docker-scaling.md
new file mode 100644
index 0000000..90db059
--- /dev/null
+++ b/_docs/docker-scaling.md
@@ -0,0 +1,385 @@
+# Docker Scaling Guide
+
+This guide covers scaling strategies for the Solana MCP Server in Docker environments.
+
+## Overview
+
+While Docker doesn't have native autoscaling like Kubernetes, there are several approaches to scale the Solana MCP Server based on demand:
+
+1. **Manual Scaling** - Scale replicas manually using Docker Compose
+2. **Docker Swarm Mode** - Built-in orchestration with basic scaling
+3. **External Autoscalers** - Third-party tools for dynamic scaling
+
+## Manual Scaling with Docker Compose
+
+### Basic docker-compose.yml
+
+```yaml
+version: '3.8'
+services:
+  solana-mcp-server:
+    build: .
+    ports:
+      - "8080"
+    environment:
+      - SOLANA_RPC_URL=https://api.mainnet-beta.solana.com
+      - SOLANA_COMMITMENT=confirmed
+      - RUST_LOG=info
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 30s
+    deploy:
+      resources:
+        limits:
+          cpus: '0.5'
+          memory: 1G
+        reservations:
+          cpus: '0.25'
+          memory: 512M
+    restart: unless-stopped
+
+  nginx:
+    image: nginx:alpine
+    ports:
+      - "80:80"
+    volumes:
+      - ./nginx.conf:/etc/nginx/nginx.conf:ro
+    depends_on:
+      - solana-mcp-server
+```
+
+### Scaling Commands
+
+```bash
+# Scale to 3 replicas
+docker-compose up --scale solana-mcp-server=3 -d
+
+# Scale down to 1 replica
+docker-compose up --scale solana-mcp-server=1 -d
+
+# Check current scale
+docker-compose ps
+```
+
+### Load Balancer Configuration (nginx.conf)
+
+```nginx
+events {
+    worker_connections 1024;
+}
+
+http {
+    upstream solana_mcp_backend {
+        least_conn;
+        server solana-mcp-server_solana-mcp-server_1:8080;
+        server solana-mcp-server_solana-mcp-server_2:8080;
+        server solana-mcp-server_solana-mcp-server_3:8080;
+    }
+
+    server {
+        listen 80;
+        
+        # Health check endpoint
+        location /health {
+            proxy_pass http://solana_mcp_backend;
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+        }
+        
+        # Metrics endpoint (for monitoring)
+        location /metrics {
+            proxy_pass http://solana_mcp_backend;
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+        }
+        
+        # Main application (if needed)
+        location / {
+            proxy_pass http://solana_mcp_backend;
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        }
+    }
+}
+```
+
+## Docker Swarm Mode
+
+Docker Swarm provides basic orchestration and scaling capabilities.
+
+### Initialize Swarm
+
+```bash
+# Initialize swarm (on manager node)
+docker swarm init
+
+# Join worker nodes
+docker swarm join --token <token> <manager-ip>:2377
+```
+
+### Deploy Stack
+
+Create `docker-stack.yml`:
+
+```yaml
+version: '3.8'
+services:
+  solana-mcp-server:
+    image: solana-mcp-server:latest
+    ports:
+      - target: 8080
+        published: 8080
+        protocol: tcp
+        mode: ingress
+    environment:
+      - SOLANA_RPC_URL=https://api.mainnet-beta.solana.com
+      - SOLANA_COMMITMENT=confirmed
+      - RUST_LOG=info
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 30s
+    deploy:
+      replicas: 2
+      resources:
+        limits:
+          cpus: '0.5'
+          memory: 1G
+        reservations:
+          cpus: '0.25'
+          memory: 512M
+      restart_policy:
+        condition: on-failure
+        delay: 5s
+        max_attempts: 3
+        window: 120s
+      update_config:
+        parallelism: 1
+        delay: 10s
+        failure_action: rollback
+        monitor: 60s
+        max_failure_ratio: 0.3
+      rollback_config:
+        parallelism: 1
+        delay: 5s
+        failure_action: pause
+        monitor: 60s
+        max_failure_ratio: 0.3
+    networks:
+      - solana-mcp-network
+
+networks:
+  solana-mcp-network:
+    driver: overlay
+```
+
+### Swarm Scaling Commands
+
+```bash
+# Deploy the stack
+docker stack deploy -c docker-stack.yml solana-mcp
+
+# Scale the service
+docker service scale solana-mcp_solana-mcp-server=5
+
+# Check service status
+docker service ls
+docker service ps solana-mcp_solana-mcp-server
+
+# Update the service
+docker service update --image solana-mcp-server:new-version solana-mcp_solana-mcp-server
+
+# Remove the stack
+docker stack rm solana-mcp
+```
+
+## External Autoscaling Solutions
+
+### 1. Prometheus + Custom Autoscaler
+
+Create a simple autoscaler script:
+
+```bash
+#!/bin/bash
+# autoscaler.sh - Simple CPU-based autoscaler
+
+STACK_NAME="solana-mcp"
+SERVICE_NAME="${STACK_NAME}_solana-mcp-server"
+MIN_REPLICAS=1
+MAX_REPLICAS=10
+CPU_THRESHOLD=70
+CHECK_INTERVAL=30
+
+while true; do
+    # Get current replicas
+    CURRENT_REPLICAS=$(docker service inspect --format='{{.Spec.Mode.Replicated.Replicas}}' $SERVICE_NAME)
+    
+    # Get average CPU usage (requires monitoring setup)
+    CPU_USAGE=$(curl -s http://localhost:9090/api/v1/query?query=avg\(rate\(container_cpu_usage_seconds_total\{name=~\"$SERVICE_NAME.*\"\}\[1m\]\)\)*100 | jq -r '.data.result[0].value[1]' 2>/dev/null || echo "0")
+    
+    echo "Current replicas: $CURRENT_REPLICAS, CPU usage: $CPU_USAGE%"
+    
+    # Scale up if CPU is high
+    if (( $(echo "$CPU_USAGE > $CPU_THRESHOLD" | bc -l) )) && (( CURRENT_REPLICAS < MAX_REPLICAS )); then
+        NEW_REPLICAS=$((CURRENT_REPLICAS + 1))
+        echo "Scaling up to $NEW_REPLICAS replicas"
+        docker service scale $SERVICE_NAME=$NEW_REPLICAS
+    
+    # Scale down if CPU is low
+    elif (( $(echo "$CPU_USAGE < $((CPU_THRESHOLD - 20))" | bc -l) )) && (( CURRENT_REPLICAS > MIN_REPLICAS )); then
+        NEW_REPLICAS=$((CURRENT_REPLICAS - 1))
+        echo "Scaling down to $NEW_REPLICAS replicas"
+        docker service scale $SERVICE_NAME=$NEW_REPLICAS
+    fi
+    
+    sleep $CHECK_INTERVAL
+done
+```
+
+Make it executable and run:
+
+```bash
+chmod +x autoscaler.sh
+./autoscaler.sh &
+```
+
+### 2. Using Prometheus and AlertManager
+
+Configure Prometheus rules in `prometheus-rules.yml`:
+
+```yaml
+groups:
+- name: docker-scaling
+  rules:
+  - alert: HighCPUUsage
+    expr: avg(rate(container_cpu_usage_seconds_total{name=~"solana-mcp.*"}[1m])) * 100 > 70
+    for: 2m
+    labels:
+      severity: warning
+      action: scale_up
+    annotations:
+      summary: "High CPU usage detected"
+      description: "CPU usage is above 70% for 2 minutes"
+      
+  - alert: LowCPUUsage  
+    expr: avg(rate(container_cpu_usage_seconds_total{name=~"solana-mcp.*"}[1m])) * 100 < 30
+    for: 5m
+    labels:
+      severity: info
+      action: scale_down
+    annotations:
+      summary: "Low CPU usage detected"
+      description: "CPU usage is below 30% for 5 minutes"
+```
+
+### 3. Third-party Solutions
+
+#### Orbiter (Docker Swarm Autoscaler)
+```bash
+# Install Orbiter
+docker service create \
+  --name orbiter \
+  --mount type=bind,source=/var/run/docker.sock,target=/var/run/docker.sock \
+  --constraint 'node.role == manager' \
+  gianarb/orbiter:latest \
+  --metrics-addr=http://prometheus:9090 \
+  --log-level=debug
+```
+
+## Monitoring and Metrics
+
+### Prometheus Configuration
+
+Add to `prometheus.yml`:
+
+```yaml
+scrape_configs:
+  - job_name: 'solana-mcp-server'
+    static_configs:
+      - targets: ['solana-mcp-server:8080']
+    metrics_path: '/metrics'
+    scrape_interval: 30s
+    
+  - job_name: 'docker'
+    static_configs:
+      - targets: ['docker-exporter:9323']
+```
+
+### Key Metrics for Scaling Decisions
+
+1. **CPU Usage**: `rate(container_cpu_usage_seconds_total[1m])`
+2. **Memory Usage**: `container_memory_working_set_bytes`
+3. **Request Rate**: `rate(solana_mcp_rpc_requests_total[1m])`
+4. **Response Time**: `histogram_quantile(0.95, rate(solana_mcp_rpc_request_duration_seconds_bucket[1m]))`
+5. **Error Rate**: `rate(solana_mcp_rpc_requests_failed_total[1m])`
+
+### Grafana Dashboard
+
+Import the dashboard configuration from `/docs/grafana-dashboard.json` for visualization.
+
+## Best Practices
+
+1. **Resource Limits**: Always set CPU and memory limits
+2. **Health Checks**: Configure proper health checks for containers
+3. **Graceful Shutdown**: Ensure containers handle SIGTERM gracefully
+4. **Load Balancing**: Use nginx or HAProxy for load balancing
+5. **Monitoring**: Monitor key metrics for scaling decisions
+6. **Testing**: Test scaling behavior under load
+
+## Load Testing
+
+Use tools like `wrk` or `ab` to test scaling:
+
+```bash
+# Install wrk
+sudo apt-get install wrk
+
+# Test with increasing load
+wrk -t12 -c400 -d30s http://localhost:8080/health
+
+# Monitor scaling during test
+watch -n 2 'docker service ps solana-mcp_solana-mcp-server'
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Containers not scaling**: Check resource constraints and Docker daemon logs
+2. **Load balancer not finding backends**: Verify service discovery and network configuration
+3. **High memory usage**: Monitor for memory leaks and adjust limits
+4. **Slow scaling**: Adjust check intervals and thresholds
+
+### Debug Commands
+
+```bash
+# Check service logs
+docker service logs -f solana-mcp_solana-mcp-server
+
+# Inspect service configuration
+docker service inspect solana-mcp_solana-mcp-server
+
+# Check node resources
+docker node ls
+docker node inspect self
+
+# Monitor resource usage
+docker stats
+```
+
+## Limitations
+
+Unlike Kubernetes HPA, Docker-based scaling has limitations:
+
+1. **No built-in custom metrics support**
+2. **Manual configuration required for autoscaling**
+3. **Limited to node-level resource monitoring**
+4. **No automatic rollback on scaling failures**
+
+For production workloads requiring sophisticated autoscaling, consider using Kubernetes with the HPA configuration provided in `/k8s/hpa.yaml`.
\ No newline at end of file
diff --git a/_docs/mcp-json-rpc-api.md b/_docs/mcp-json-rpc-api.md
new file mode 100644
index 0000000..52a25f5
--- /dev/null
+++ b/_docs/mcp-json-rpc-api.md
@@ -0,0 +1,238 @@
+# MCP JSON-RPC API Specification
+
+This document describes the Model Context Protocol (MCP) JSON-RPC API implementation for the Solana MCP Server.
+
+## Overview
+
+The Solana MCP Server implements the full MCP JSON-RPC 2.0 specification, providing a standards-compliant interface for AI clients to interact with the Solana blockchain.
+
+## API Endpoints
+
+### HTTP Web Service Mode
+
+When running in web service mode, the server exposes the following endpoints:
+
+- `POST /api/mcp` - MCP JSON-RPC 2.0 API endpoint
+- `GET /health` - Health check and capability information
+- `GET /metrics` - Prometheus metrics (Prometheus format)
+
+## MCP JSON-RPC 2.0 Specification
+
+All MCP requests and responses follow the JSON-RPC 2.0 specification with MCP-specific extensions.
+
+### Request Format
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "methodName",
+  "params": {
+    // Method-specific parameters
+  }
+}
+```
+
+### Response Format
+
+#### Success Response
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": {
+    // Method-specific result data
+  }
+}
+```
+
+#### Error Response
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "error": {
+    "code": -32603,
+    "message": "Internal error",
+    "data": {
+      "protocolVersion": "2024-11-05"
+    }
+  }
+}
+```
+
+## Content Types
+
+The MCP specification supports multiple content types with optional annotations:
+
+### Text Content
+```json
+{
+  "type": "text",
+  "text": "Content text here",
+  "annotations": {
+    "audience": ["user", "assistant"],
+    "priority": 0.8,
+    "lastModified": "2024-01-15T10:00:00Z"
+  }
+}
+```
+
+### Image Content
+```json
+{
+  "type": "image",
+  "data": "base64-encoded-image-data",
+  "mimeType": "image/png",
+  "annotations": {
+    "audience": ["user"],
+    "priority": 1.0
+  }
+}
+```
+
+### Resource Content
+```json
+{
+  "type": "resource",
+  "resource": {
+    "uri": "https://example.com/resource",
+    "mimeType": "application/json"
+  },
+  "annotations": {
+    "priority": 0.5
+  }
+}
+```
+
+## Annotations
+
+Annotations provide metadata about content objects:
+
+- `audience`: Array of intended recipients (`["user", "assistant"]`)
+- `priority`: Importance level (0.0 = least important, 1.0 = most important)
+- `lastModified`: ISO 8601 timestamp of last modification
+
+## Error Codes
+
+Standard JSON-RPC 2.0 error codes are used:
+
+- `-32700`: Parse error
+- `-32600`: Invalid Request
+- `-32601`: Method not found
+- `-32602`: Invalid params
+- `-32603`: Internal error
+- `-32002`: Server not initialized (MCP-specific)
+
+## Health Check Response
+
+The `/health` endpoint returns detailed server information:
+
+```json
+{
+  "status": "ok",
+  "service": "solana-mcp-server",
+  "version": "1.0.2",
+  "protocol": "2024-11-05",
+  "capabilities": {
+    "tools": true,
+    "resources": true,
+    "prompts": false,
+    "sampling": false
+  }
+}
+```
+
+## Headers
+
+### Request Headers
+- `Content-Type: application/json` (required)
+- `Accept: application/json` (recommended)
+
+### Response Headers  
+- `Content-Type: application/json`
+- `X-MCP-Version: 2024-11-05` (protocol version)
+- `Cache-Control: no-cache`
+
+## Client Usage Examples
+
+### Python Example
+```python
+import requests
+import json
+
+# Initialize MCP session
+init_request = {
+    "jsonrpc": "2.0",
+    "id": 1,
+    "method": "initialize",
+    "params": {
+        "protocolVersion": "2024-11-05",
+        "capabilities": {},
+        "clientInfo": {
+            "name": "my-client",
+            "version": "1.0.0"
+        }
+    }
+}
+
+response = requests.post(
+    "http://localhost:3000/api/mcp",
+    headers={"Content-Type": "application/json"},
+    json=init_request
+)
+
+print(response.json())
+```
+
+### JavaScript Example
+```javascript
+const mcpRequest = {
+  jsonrpc: "2.0",
+  id: 2,
+  method: "tools/call",
+  params: {
+    name: "getBalance",
+    arguments: {
+      pubkey: "11111111111111111111111111111112"
+    }
+  }
+};
+
+fetch("http://localhost:3000/api/mcp", {
+  method: "POST",
+  headers: {
+    "Content-Type": "application/json"
+  },
+  body: JSON.stringify(mcpRequest)
+})
+.then(response => response.json())
+.then(data => console.log(data));
+```
+
+## Validation
+
+The server performs strict validation on all requests:
+
+1. **JSON-RPC 2.0 compliance**: Validates `jsonrpc`, `method`, and `id` fields
+2. **Content-Type validation**: Ensures `application/json` content type
+3. **Parameter validation**: Validates method-specific parameters
+4. **Protocol version compatibility**: Checks MCP protocol version
+
+## Security Considerations
+
+- All HTTP responses include appropriate caching headers
+- Request validation prevents malformed JSON-RPC requests
+- Parameter sanitization prevents injection attacks
+- Network detection for proper metrics labeling
+- Rate limiting should be implemented at the reverse proxy level
+
+## Compatibility
+
+This implementation follows:
+- JSON-RPC 2.0 specification
+- MCP Protocol version 2024-11-05
+- HTTP/1.1 and HTTP/2 standards
+- OpenAPI 3.0 compatible (documentation available separately)
+
+The server maintains full backward compatibility with existing stdio transport clients while providing modern HTTP JSON-RPC capabilities for web-based integrations.
\ No newline at end of file
diff --git a/_docs/metrics.md b/_docs/metrics.md
new file mode 100644
index 0000000..7919459
--- /dev/null
+++ b/_docs/metrics.md
@@ -0,0 +1,298 @@
+# Metrics Documentation
+
+The Solana MCP Server exposes comprehensive metrics for monitoring, alerting, and autoscaling. This document describes the available metrics and how to use them.
+
+## Metrics Endpoint
+
+- **URL**: `http://<server>:8080/metrics`
+- **Format**: Prometheus text format
+- **Content-Type**: `text/plain; version=0.0.4`
+
+## Available Metrics
+
+### RPC Request Metrics
+
+#### `solana_mcp_rpc_requests_total`
+- **Type**: Counter
+- **Description**: Total number of RPC requests processed
+- **Labels**: 
+  - `method`: RPC method name (e.g., `getBalance`, `getHealth`)
+  - `network`: Network identifier (e.g., `mainnet`, `testnet`)
+
+#### `solana_mcp_rpc_requests_successful_total`
+- **Type**: Counter  
+- **Description**: Number of successful RPC requests
+- **Labels**: 
+  - `method`: RPC method name
+  - `network`: Network identifier
+
+#### `solana_mcp_rpc_requests_failed_total`
+- **Type**: Counter
+- **Description**: Number of failed RPC requests
+- **Labels**:
+  - `method`: RPC method name  
+  - `network`: Network identifier
+  - `error_type`: Error category (`validation`, `rpc`, `network`, `auth`, `server`)
+
+#### `solana_mcp_rpc_request_duration_seconds`
+- **Type**: Histogram
+- **Description**: Request duration in seconds
+- **Labels**:
+  - `method`: RPC method name
+  - `network`: Network identifier
+- **Buckets**: 0.001, 0.005, 0.01, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0
+
+#### `solana_mcp_rpc_errors_total`
+- **Type**: Counter
+- **Description**: Total RPC errors by type and method
+- **Labels**:
+  - `error_type`: Error category
+  - `method`: RPC method name
+
+## Autoscaling Metrics
+
+The following derived metrics are used for Kubernetes HPA:
+
+### `solana_mcp_rpc_requests_per_second`
+- **Derived from**: `rate(solana_mcp_rpc_requests_total[1m])`
+- **Usage**: Scale up when > 100 RPS per pod
+- **Formula**: `rate(solana_mcp_rpc_requests_total{pod="<pod-name>"}[1m])`
+
+### `solana_mcp_rpc_request_duration_seconds_p95`
+- **Derived from**: `histogram_quantile(0.95, rate(solana_mcp_rpc_request_duration_seconds_bucket[1m]))`
+- **Usage**: Scale up when P95 latency > 500ms
+- **Formula**: `histogram_quantile(0.95, rate(solana_mcp_rpc_request_duration_seconds_bucket{pod="<pod-name>"}[1m]))`
+
+## Health Endpoint
+
+- **URL**: `http://<server>:8080/health`
+- **Response**: `{"status":"ok","service":"solana-mcp-server"}`
+- **Usage**: Kubernetes liveness and readiness probes
+
+## PromQL Query Examples
+
+### Basic Queries
+
+```promql
+# Total request rate across all pods
+sum(rate(solana_mcp_rpc_requests_total[5m]))
+
+# Error rate by method
+sum(rate(solana_mcp_rpc_requests_failed_total[5m])) by (method)
+
+# Average request duration
+avg(rate(solana_mcp_rpc_request_duration_seconds_sum[5m]) / rate(solana_mcp_rpc_request_duration_seconds_count[5m]))
+
+# P95 latency
+histogram_quantile(0.95, sum(rate(solana_mcp_rpc_request_duration_seconds_bucket[5m])) by (le))
+```
+
+### Autoscaling Queries
+
+```promql
+# Request rate per pod (used by HPA)
+rate(solana_mcp_rpc_requests_total[1m])
+
+# P95 latency per pod (used by HPA)
+histogram_quantile(0.95, rate(solana_mcp_rpc_request_duration_seconds_bucket[1m]))
+
+# Error rate percentage
+(
+  sum(rate(solana_mcp_rpc_requests_failed_total[5m])) /
+  sum(rate(solana_mcp_rpc_requests_total[5m]))
+) * 100
+```
+
+### Resource Utilization
+
+```promql
+# CPU utilization per pod
+rate(container_cpu_usage_seconds_total{pod=~"solana-mcp-server-.*"}[5m])
+
+# Memory utilization per pod  
+container_memory_working_set_bytes{pod=~"solana-mcp-server-.*"}
+
+# Network traffic per pod
+rate(container_network_receive_bytes_total{pod=~"solana-mcp-server-.*"}[5m])
+rate(container_network_transmit_bytes_total{pod=~"solana-mcp-server-.*"}[5m])
+```
+
+## Alerting Rules
+
+### Critical Alerts
+
+```yaml
+groups:
+- name: solana-mcp-server
+  rules:
+  # High error rate
+  - alert: SolanaMcpHighErrorRate
+    expr: |
+      (
+        sum(rate(solana_mcp_rpc_requests_failed_total[5m])) /
+        sum(rate(solana_mcp_rpc_requests_total[5m]))
+      ) > 0.1
+    for: 2m
+    labels:
+      severity: critical
+    annotations:
+      summary: "High error rate in Solana MCP Server"
+      description: "Error rate is {{ $value | humanizePercentage }} for 2 minutes"
+
+  # High latency
+  - alert: SolanaMcpHighLatency
+    expr: |
+      histogram_quantile(0.95,
+        sum(rate(solana_mcp_rpc_request_duration_seconds_bucket[5m])) by (le)
+      ) > 2.0
+    for: 5m
+    labels:
+      severity: warning
+    annotations:
+      summary: "High latency in Solana MCP Server"
+      description: "P95 latency is {{ $value }}s for 5 minutes"
+
+  # No requests (service down)
+  - alert: SolanaMcpNoRequests
+    expr: |
+      sum(rate(solana_mcp_rpc_requests_total[10m])) == 0
+    for: 5m
+    labels:
+      severity: critical
+    annotations:
+      summary: "Solana MCP Server receiving no requests"
+      description: "No requests received for 5 minutes"
+```
+
+## Grafana Dashboard
+
+### Key Panels
+
+1. **Request Rate**: `sum(rate(solana_mcp_rpc_requests_total[5m])) by (method)`
+2. **Error Rate**: `sum(rate(solana_mcp_rpc_requests_failed_total[5m])) by (error_type)`
+3. **Latency Percentiles**: 
+   - P50: `histogram_quantile(0.50, sum(rate(solana_mcp_rpc_request_duration_seconds_bucket[5m])) by (le))`
+   - P95: `histogram_quantile(0.95, sum(rate(solana_mcp_rpc_request_duration_seconds_bucket[5m])) by (le))`
+   - P99: `histogram_quantile(0.99, sum(rate(solana_mcp_rpc_request_duration_seconds_bucket[5m])) by (le))`
+4. **Pod Count**: `count(up{job="solana-mcp-server"})`
+5. **HPA Status**: Custom panel showing current/desired replicas
+
+### Sample Dashboard JSON
+
+```json
+{
+  "dashboard": {
+    "title": "Solana MCP Server",
+    "panels": [
+      {
+        "title": "Request Rate",
+        "type": "graph", 
+        "targets": [
+          {
+            "expr": "sum(rate(solana_mcp_rpc_requests_total[5m])) by (method)",
+            "legendFormat": "{{method}}"
+          }
+        ]
+      },
+      {
+        "title": "Error Rate %",
+        "type": "graph",
+        "targets": [
+          {
+            "expr": "(sum(rate(solana_mcp_rpc_requests_failed_total[5m])) by (method) / sum(rate(solana_mcp_rpc_requests_total[5m])) by (method)) * 100",
+            "legendFormat": "{{method}}"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+## Integration with Kubernetes HPA
+
+The metrics are designed to work with Kubernetes Horizontal Pod Autoscaler:
+
+1. **Resource Metrics**: CPU and memory utilization (built-in)
+2. **Custom Metrics**: Request rate and latency (via Prometheus Adapter)
+
+### HPA Configuration Example
+
+```yaml
+apiVersion: autoscaling/v2
+kind: HorizontalPodAutoscaler
+metadata:
+  name: solana-mcp-server-hpa
+spec:
+  scaleTargetRef:
+    apiVersion: apps/v1
+    kind: Deployment
+    name: solana-mcp-server
+  minReplicas: 1
+  maxReplicas: 10
+  metrics:
+  - type: Resource
+    resource:
+      name: cpu
+      target:
+        type: Utilization
+        averageUtilization: 70
+  - type: Pods
+    pods:
+      metric:
+        name: solana_mcp_rpc_requests_per_second
+      target:
+        type: AverageValue
+        averageValue: "100"
+```
+
+## Troubleshooting
+
+### Metrics Not Available
+
+1. **Check metrics endpoint**:
+   ```bash
+   curl http://localhost:8080/metrics
+   ```
+
+2. **Verify Prometheus scraping**:
+   ```bash
+   kubectl logs -l app=prometheus
+   ```
+
+3. **Check ServiceMonitor**:
+   ```bash
+   kubectl get servicemonitor solana-mcp-server-monitor -o yaml
+   ```
+
+### HPA Not Scaling
+
+1. **Check custom metrics**:
+   ```bash
+   kubectl get --raw "/apis/custom.metrics.k8s.io/v1beta1/namespaces/default/pods/*/solana_mcp_rpc_requests_per_second"
+   ```
+
+2. **Verify Prometheus Adapter**:
+   ```bash
+   kubectl logs -n monitoring deployment/prometheus-adapter
+   ```
+
+3. **Check HPA status**:
+   ```bash
+   kubectl describe hpa solana-mcp-server-hpa
+   ```
+
+## Performance Impact
+
+The metrics collection has minimal performance impact:
+
+- **CPU overhead**: < 1% under normal load
+- **Memory overhead**: ~10MB for metrics storage
+- **Network overhead**: ~1KB/s for metrics scraping (30s interval)
+
+## Security Considerations
+
+- Metrics endpoint is exposed on all interfaces (0.0.0.0:8080)
+- No authentication required for metrics access
+- Consider using network policies to restrict access
+- Metrics may contain sensitive timing information about operations
\ No newline at end of file
diff --git a/_docs/security-audit.md b/_docs/security-audit.md
new file mode 100644
index 0000000..af83454
--- /dev/null
+++ b/_docs/security-audit.md
@@ -0,0 +1,66 @@
+# Security Audit Documentation
+
+## Overview
+
+This document describes the security audit status for the solana-mcp-server project and explains the current state of known vulnerabilities.
+
+## Current Security Status
+
+### Known Vulnerabilities (Acceptable Risk)
+
+The following vulnerabilities are present as transitive dependencies from the Solana ecosystem and cannot be easily resolved without breaking compatibility:
+
+#### RUSTSEC-2024-0344: curve25519-dalek Timing Variability
+- **Package**: curve25519-dalek v3.2.0 
+- **Issue**: Timing variability in `Scalar29::sub`/`Scalar52::sub`
+- **Patched Version**: >=4.1.3
+- **Status**: Both vulnerable (3.2.0) and patched (4.1.3) versions present in dependency tree
+- **Risk Assessment**: Low - This affects cryptographic operations in the Solana client libraries, not our server logic
+- **Mitigation**: We've added curve25519-dalek v4.1.3 as a direct dependency to force the resolver to prefer the secure version
+
+#### RUSTSEC-2022-0093: ed25519-dalek Double Public Key Signing 
+- **Package**: ed25519-dalek v1.0.1
+- **Issue**: Double Public Key Signing Function Oracle Attack
+- **Patched Version**: >=2.0.0
+- **Status**: Both vulnerable (1.0.1) and patched (2.2.0) versions present in dependency tree
+- **Risk Assessment**: Low - This affects key signing operations in the Solana client libraries, not our server logic
+- **Mitigation**: We've added ed25519-dalek v2.2.0 as a direct dependency to force the resolver to prefer the secure version
+
+### Unmaintained Dependencies (Informational)
+
+#### derivative v2.2.0
+- **Status**: Unmaintained since 2024-06-26
+- **Impact**: Used by Solana ecosystem for derive macros
+- **Alternatives**: derive_more, derive-where, educe
+- **Action**: Monitor Solana ecosystem updates
+
+#### paste v1.0.15  
+- **Status**: Unmaintained since 2024-10-07
+- **Impact**: Used for token pasting in procedural macros
+- **Alternatives**: pastey
+- **Action**: Monitor Solana ecosystem updates
+
+## Security Audit Workflow
+
+Our CI/CD pipeline includes a security audit workflow that:
+
+1. **Runs weekly** and on dependency changes
+2. **Uses cargo-audit** with JSON output for detailed reporting
+3. **Reports all vulnerabilities** found in the dependency tree
+4. **Continues deployment** for known acceptable risks from Solana ecosystem
+5. **Fails builds** for new high-severity vulnerabilities
+
+## Monitoring and Updates
+
+- **Weekly audits** via GitHub Actions detect new vulnerabilities
+- **Dependency updates** are applied when Solana ecosystem releases updates
+- **Security patches** are applied through direct dependencies and patches
+- **Risk assessment** is updated as new vulnerabilities are discovered
+
+## Contact
+
+For security concerns or questions about our audit process, please:
+1. Review this documentation
+2. Check current GitHub Actions audit results
+3. Open an issue for questions about security posture
+4. Contact maintainers for private security disclosures
\ No newline at end of file
diff --git a/_docs/timeout-configuration.md b/_docs/timeout-configuration.md
new file mode 100644
index 0000000..0d6a3a1
--- /dev/null
+++ b/_docs/timeout-configuration.md
@@ -0,0 +1,206 @@
+# Timeout Configuration
+
+The Solana MCP Server provides comprehensive timeout configurations to prevent hanging operations and ensure reliable performance in production environments.
+
+## Overview
+
+All timeout settings are configurable through the `config.json` file or fall back to sensible defaults. The server includes timeouts for:
+
+- HTTP API requests
+- WebSocket connections and messages
+- RPC subscription creation
+- Connection idle timeout
+
+## Configuration
+
+### Using config.json
+
+```json
+{
+  "rpc_url": "https://api.opensvm.com",
+  "commitment": "confirmed",
+  "protocol_version": "2024-11-05",
+  "timeouts": {
+    "http_request_seconds": 30,
+    "websocket_connection_seconds": 30,
+    "websocket_message_seconds": 10,
+    "subscription_seconds": 15,
+    "max_idle_seconds": 300
+  }
+}
+```
+
+### Timeout Settings
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| `http_request_seconds` | 30 | Maximum time for HTTP API requests |
+| `websocket_connection_seconds` | 30 | WebSocket connection establishment timeout |
+| `websocket_message_seconds` | 10 | Individual WebSocket message timeout |
+| `subscription_seconds` | 15 | RPC subscription creation timeout |
+| `max_idle_seconds` | 300 | Maximum idle time before closing connections |
+
+### Environment Variables
+
+If no `config.json` is provided, the server uses default timeout values. Individual timeout settings cannot currently be overridden via environment variables.
+
+## GitHub Actions Timeouts
+
+The CI/CD workflows have been updated with comprehensive timeout protection:
+
+### Build Workflow (`build.yml`)
+- **Overall job timeout**: 45 minutes
+- **Build step**: 15 minutes
+- **Dependency check**: 5 minutes  
+- **Test execution**: 20 minutes
+
+### Benchmark Workflow (`benchmark.yml`)
+- **Overall job timeout**: 60 minutes
+- **Individual benchmarks**: 15 minutes each
+- **Command-level timeout**: 10 minutes via `timeout` command
+
+### Audit Workflow (`audit.yml`)
+- **Overall job timeout**: 15 minutes
+- **cargo-audit installation**: 5 minutes
+- **Dependency check**: 3 minutes
+- **Audit execution**: 5 minutes
+
+### Release Workflow (`release.yml`)
+- **Overall job timeout**: 60 minutes (for cross-compilation)
+
+## Server Implementation
+
+### HTTP Server Timeouts
+
+The HTTP server includes:
+- Request-level timeouts via `tower-http::timeout::TimeoutLayer`
+- Graceful shutdown timeout (10 seconds)
+- Configurable per-request timeout
+
+### WebSocket Server Timeouts
+
+The WebSocket server provides:
+- Connection establishment timeout
+- Message send/receive timeouts
+- Subscription creation timeout
+- Idle connection cleanup
+- Ping/pong heartbeat mechanism
+
+### Error Handling
+
+When timeouts occur:
+- HTTP requests return `408 Request Timeout`
+- WebSocket connections are gracefully closed
+- Failed subscriptions return JSON-RPC error responses
+- All timeout events are logged with appropriate severity
+
+## Monitoring and Diagnostics
+
+Timeout events are exposed through:
+- **Prometheus metrics**: `solana_mcp_rpc_requests_failed_total{error_type="timeout"}`
+- **Structured logging**: JSON-formatted timeout logs
+- **Health endpoint**: Connection and timeout status
+
+## Best Practices
+
+### Development
+- Use shorter timeouts (5-15 seconds) for development
+- Enable debug logging to monitor timeout behavior
+- Test with network delays and poor connectivity
+
+### Production
+- Use longer timeouts (30-60 seconds) for production stability
+- Monitor timeout metrics for performance optimization
+- Configure load balancer timeouts to exceed server timeouts
+
+### High-Load Environments
+- Increase `max_idle_seconds` for persistent connections
+- Reduce `websocket_message_seconds` for responsive interaction
+- Monitor connection pool utilization
+
+## Troubleshooting
+
+### Common Issues
+
+**WebSocket connections timing out:**
+```json
+{
+  "timeouts": {
+    "websocket_connection_seconds": 60,
+    "websocket_message_seconds": 20
+  }
+}
+```
+
+**HTTP requests timing out:**
+```json
+{
+  "timeouts": {
+    "http_request_seconds": 60
+  }
+}
+```
+
+**Subscription creation failing:**
+```json
+{
+  "timeouts": {
+    "subscription_seconds": 30
+  }
+}
+```
+
+### Debugging
+
+Enable debug logging to see timeout behavior:
+```bash
+RUST_LOG=debug solana-mcp-server stdio
+```
+
+Check timeout metrics:
+```bash
+curl http://localhost:8080/metrics | grep timeout
+```
+
+## Examples
+
+### Conservative Configuration (High Reliability)
+```json
+{
+  "timeouts": {
+    "http_request_seconds": 60,
+    "websocket_connection_seconds": 45,
+    "websocket_message_seconds": 20,
+    "subscription_seconds": 30,
+    "max_idle_seconds": 600
+  }
+}
+```
+
+### Aggressive Configuration (Low Latency)
+```json
+{
+  "timeouts": {
+    "http_request_seconds": 15,
+    "websocket_connection_seconds": 10,
+    "websocket_message_seconds": 5,
+    "subscription_seconds": 10,
+    "max_idle_seconds": 120
+  }
+}
+```
+
+### Load Balancer Integration
+For systems behind load balancers, ensure server timeouts are less than load balancer timeouts:
+
+```json
+{
+  "timeouts": {
+    "http_request_seconds": 25
+  }
+}
+```
+
+*If load balancer timeout is 30 seconds*
+
+This comprehensive timeout system ensures the Solana MCP Server never hangs indefinitely and provides predictable behavior under all network conditions.
\ No newline at end of file
diff --git a/_docs/web-service.md b/_docs/web-service.md
new file mode 100644
index 0000000..5bbed76
--- /dev/null
+++ b/_docs/web-service.md
@@ -0,0 +1,359 @@
+# Solana MCP Server - Web Service Mode
+
+The Solana MCP Server supports running as an HTTP web service, providing full MCP JSON-RPC 2.0 API compliance for web-based integrations.
+
+## Overview
+
+When running in web service mode, the server provides:
+- **Full MCP JSON-RPC 2.0 compliance** following the official specification  
+- **Proper content type handling** with annotations support
+- **Standards-compliant error responses** with protocol versioning
+- **Health checks** with capability information
+- **Prometheus metrics** integration
+
+## Running as Web Service
+
+### Basic Usage
+
+```bash
+# Run on default port 3000
+solana-mcp-server web
+
+# Run on custom port  
+solana-mcp-server web --port 8000
+```
+
+### Available Endpoints
+
+When running in web service mode, the server provides:
+
+#### POST /api/mcp
+- **Purpose**: MCP JSON-RPC 2.0 API endpoint
+- **Content-Type**: `application/json` (required)
+- **Description**: Accepts MCP JSON-RPC requests following the 2024-11-05 specification
+- **Features**: Full protocol validation, proper error handling, content annotations
+
+#### GET /health
+- **Purpose**: Health check and capability information
+- **Response**: Detailed server status including protocol version and capabilities
+- **Description**: Returns comprehensive server health and MCP capability information
+
+#### GET /metrics
+- **Purpose**: Prometheus metrics endpoint
+- **Content-Type**: `text/plain; version=0.0.4`
+- **Description**: Exposes Prometheus-format metrics for monitoring
+
+## API Usage Examples
+
+### Initialize MCP Session
+
+```bash
+curl -X POST http://localhost:3000/api/mcp \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 1,
+    "method": "initialize",
+    "params": {
+      "protocolVersion": "2024-11-05",
+      "capabilities": {},
+      "clientInfo": {
+        "name": "my-client",
+        "version": "1.0.0"
+      }
+    }
+  }'
+```
+
+### List Available Tools
+
+```bash
+curl -X POST http://localhost:3000/api/mcp \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 2,
+    "method": "tools/list",
+    "params": {}
+  }'
+```
+
+### Call a Tool (Get Account Balance)
+
+```bash
+curl -X POST http://localhost:3000/api/mcp \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 3,
+    "method": "tools/call",
+    "params": {
+      "name": "getBalance",
+      "arguments": {
+        "pubkey": "11111111111111111111111111111112"
+      }
+    }
+  }'
+```
+
+## Differences from Stdio Mode
+
+### Initialization
+- In stdio mode, the server waits for an `initialize` request
+- In web service mode, the server is automatically initialized and ready to accept requests
+
+### Session Management
+- Stdio mode maintains a single persistent session
+- Web service mode handles stateless HTTP requests (each request is independent)
+
+### Error Handling
+- Stdio mode can terminate on critical errors
+- Web service mode returns HTTP error codes and continues serving requests
+
+## Integration Examples
+
+### Using with curl
+
+```bash
+#!/bin/bash
+# Simple script to get account info via web API
+
+ACCOUNT_PUBKEY="$1"
+SERVER_URL="http://localhost:3000/api/mcp"
+
+curl -X POST "$SERVER_URL" \
+  -H "Content-Type: application/json" \
+  -d "{
+    \"jsonrpc\": \"2.0\",
+    \"id\": 1,
+    \"method\": \"tools/call\",
+    \"params\": {
+      \"name\": \"getAccountInfo\",
+      \"arguments\": {
+        \"pubkey\": \"$ACCOUNT_PUBKEY\"
+      }
+    }
+  }" | jq .
+```
+
+### Using with Python
+
+```python
+import requests
+import json
+
+class SolanaMcpClient:
+    def __init__(self, base_url="http://localhost:3000"):
+        self.base_url = base_url
+        self.api_url = f"{base_url}/api/mcp"
+        self.request_id = 0
+    
+    def call_tool(self, tool_name, arguments=None):
+        self.request_id += 1
+        payload = {
+            "jsonrpc": "2.0",
+            "id": self.request_id,
+            "method": "tools/call",
+            "params": {
+                "name": tool_name,
+                "arguments": arguments or {}
+            }
+        }
+        
+        response = requests.post(
+            self.api_url,
+            headers={"Content-Type": "application/json"},
+            json=payload
+        )
+        
+        return response.json()
+    
+    def get_balance(self, pubkey):
+        return self.call_tool("getBalance", {"pubkey": pubkey})
+    
+    def get_health(self):
+        response = requests.get(f"{self.base_url}/health")
+        return response.json()
+
+# Usage
+client = SolanaMcpClient()
+balance = client.get_balance("11111111111111111111111111111112")
+print(json.dumps(balance, indent=2))
+```
+
+### Using with JavaScript/Node.js
+
+```javascript
+class SolanaMcpClient {
+    constructor(baseUrl = 'http://localhost:3000') {
+        this.baseUrl = baseUrl;
+        this.apiUrl = `${baseUrl}/api/mcp`;
+        this.requestId = 0;
+    }
+    
+    async callTool(toolName, arguments = {}) {
+        this.requestId++;
+        const payload = {
+            jsonrpc: '2.0',
+            id: this.requestId,
+            method: 'tools/call',
+            params: {
+                name: toolName,
+                arguments: arguments
+            }
+        };
+        
+        const response = await fetch(this.apiUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(payload)
+        });
+        
+        return await response.json();
+    }
+    
+    async getBalance(pubkey) {
+        return await this.callTool('getBalance', { pubkey });
+    }
+    
+    async getHealth() {
+        const response = await fetch(`${this.baseUrl}/health`);
+        return await response.json();
+    }
+}
+
+// Usage
+const client = new SolanaMcpClient();
+client.getBalance('11111111111111111111111111111112')
+    .then(result => console.log(JSON.stringify(result, null, 2)));
+```
+
+## Monitoring and Observability
+
+### Health Checks
+Use the `/health` endpoint for liveness and readiness probes:
+
+```bash
+# Simple health check
+curl -f http://localhost:3000/health
+
+# In Kubernetes
+livenessProbe:
+  httpGet:
+    path: /health
+    port: 3000
+  initialDelaySeconds: 30
+  periodSeconds: 10
+```
+
+### Metrics Collection
+The `/metrics` endpoint provides Prometheus-compatible metrics:
+
+```bash
+# View metrics
+curl http://localhost:3000/metrics
+
+# Prometheus scrape config
+scrape_configs:
+  - job_name: 'solana-mcp-server'
+    static_configs:
+      - targets: ['localhost:3000']
+    metrics_path: '/metrics'
+```
+
+## Production Deployment
+
+### Docker Compose Example
+
+```yaml
+version: '3.8'
+services:
+  solana-mcp-server:
+    image: solana-mcp-server:latest
+    command: ["web", "--port", "3000"]
+    ports:
+      - "3000:3000"
+    environment:
+      - RUST_LOG=info
+    volumes:
+      - ./config.json:/app/config.json:ro
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+```
+
+### Kubernetes Deployment
+
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: solana-mcp-server
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: solana-mcp-server
+  template:
+    metadata:
+      labels:
+        app: solana-mcp-server
+    spec:
+      containers:
+      - name: solana-mcp-server
+        image: solana-mcp-server:latest
+        args: ["web", "--port", "3000"]
+        ports:
+        - containerPort: 3000
+        livenessProbe:
+          httpGet:
+            path: /health
+            port: 3000
+          initialDelaySeconds: 30
+          periodSeconds: 10
+        readinessProbe:
+          httpGet:
+            path: /health
+            port: 3000
+          initialDelaySeconds: 5
+          periodSeconds: 5
+        resources:
+          requests:
+            memory: "512Mi"
+            cpu: "250m"
+          limits:
+            memory: "1Gi"
+            cpu: "500m"
+
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: solana-mcp-server-service
+spec:
+  selector:
+    app: solana-mcp-server
+  ports:
+  - port: 80
+    targetPort: 3000
+  type: LoadBalancer
+```
+
+## Security Considerations
+
+- The web service mode exposes the MCP server over HTTP
+- Consider implementing authentication/authorization for production use
+- Use HTTPS in production environments
+- Configure appropriate CORS headers if needed for browser access
+- Monitor and rate-limit API usage to prevent abuse
+
+## Limitations
+
+- Web service mode does not support streaming or persistent connections
+- Each HTTP request is independent (no session state)
+- Large responses may be subject to HTTP timeout limits
+- No built-in authentication (implement at reverse proxy level)
\ No newline at end of file
diff --git a/_layouts/default.html b/_layouts/default.html
new file mode 100644
index 0000000..6dfde93
--- /dev/null
+++ b/_layouts/default.html
@@ -0,0 +1,231 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{% if page.title %}{{ page.title }} - {% endif %}{{ site.title }}</title>
+    <meta name="description" content="{{ page.description | default: site.description }}">
+    
+    <!-- SEO tags -->
+    {% seo %}
+    
+    <!-- Favicon -->
+    <link rel="icon" type="image/svg+xml" href="{{ '/assets/images/favicon.svg' | relative_url }}">
+    <link rel="icon" type="image/png" href="{{ '/assets/images/favicon.png' | relative_url }}">
+    
+    <!-- Fonts -->
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=JetBrains+Mono:wght@300;400;500&display=swap" rel="stylesheet">
+    
+    <!-- Styles -->
+    <link rel="stylesheet" href="{{ '/assets/css/main.css' | relative_url }}">
+    
+    <!-- Search -->
+    <script src="https://cdn.jsdelivr.net/npm/lunr@2.3.9/lunr.min.js"></script>
+    
+    <!-- Bookmark functionality -->
+    <script>
+        // Initialize bookmarks from localStorage
+        window.bookmarks = JSON.parse(localStorage.getItem('solana-mcp-bookmarks') || '[]');
+    </script>
+</head>
+<body class="eink-theme">
+    <!-- Skip to main content for accessibility -->
+    <a href="#main-content" class="skip-link">Skip to main content</a>
+    
+    <!-- Header -->
+    <header class="site-header">
+        <div class="container">
+            <div class="header-content">
+                <div class="site-logo">
+                    <a href="{{ '/' | relative_url }}" class="logo-link">
+                        <img src="{{ '/assets/images/logo.svg' | relative_url }}" alt="{{ site.title }}" class="logo-image">
+                        <span class="site-title">{{ site.title }}</span>
+                    </a>
+                </div>
+                
+                <!-- Navigation -->
+                <nav class="main-nav" role="navigation" aria-label="Main navigation">
+                    <ul class="nav-list">
+                        {% for link in site.nav_links %}
+                        <li class="nav-item">
+                            <a href="{{ link.url | relative_url }}" 
+                               class="nav-link {% if page.url == link.url %}active{% endif %}"
+                               {% if link.url contains 'http' %}target="_blank" rel="noopener noreferrer"{% endif %}>
+                                {{ link.title }}
+                            </a>
+                        </li>
+                        {% endfor %}
+                    </ul>
+                </nav>
+                
+                <!-- Search and utilities -->
+                <div class="header-utilities">
+                    <button class="search-toggle" id="search-toggle" aria-label="Toggle search" aria-expanded="false">
+                        <svg class="search-icon" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <circle cx="11" cy="11" r="8"></circle>
+                            <path d="m21 21-4.35-4.35"></path>
+                        </svg>
+                    </button>
+                    
+                    <button class="bookmark-toggle" id="bookmark-toggle" aria-label="Bookmark this page" 
+                            data-url="{{ page.url }}" data-title="{{ page.title | default: site.title }}">
+                        <svg class="bookmark-icon" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <path d="m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v16z"></path>
+                        </svg>
+                    </button>
+                    
+                    <button class="menu-toggle" id="menu-toggle" aria-label="Toggle menu" aria-expanded="false">
+                        <span class="menu-bar"></span>
+                        <span class="menu-bar"></span>
+                        <span class="menu-bar"></span>
+                    </button>
+                </div>
+            </div>
+        </div>
+        
+        <!-- Search overlay -->
+        <div class="search-overlay" id="search-overlay">
+            <div class="search-container">
+                <div class="search-input-wrapper">
+                    <input type="text" id="search-input" placeholder="Search documentation..." autocomplete="off">
+                    <button class="search-close" id="search-close" aria-label="Close search">×</button>
+                </div>
+                <div class="search-results" id="search-results"></div>
+            </div>
+        </div>
+    </header>
+    
+    <!-- Main content -->
+    <main id="main-content" class="main-content">
+        <div class="container">
+            {% if page.layout == 'home' %}
+                {{ content }}
+            {% else %}
+            <div class="content-layout">
+                <!-- Sidebar navigation for documentation pages -->
+                {% if page.layout == 'docs' or page.collection == 'docs' %}
+                <aside class="sidebar" role="complementary">
+                    <nav class="docs-nav" aria-label="Documentation navigation">
+                        <h3 class="docs-nav-title">Documentation</h3>
+                        <ul class="docs-nav-list">
+                            {% for category in site.categories %}
+                            <li class="docs-nav-category">
+                                <h4 class="category-title">{{ category[1].icon }} {{ category[1].title }}</h4>
+                                <p class="category-description">{{ category[1].description }}</p>
+                            </li>
+                            {% endfor %}
+                            
+                            {% assign docs = site.docs | sort: 'order' %}
+                            {% for doc in docs %}
+                            <li class="docs-nav-item">
+                                <a href="{{ doc.url | relative_url }}" 
+                                   class="docs-nav-link {% if page.url == doc.url %}active{% endif %}">
+                                    {{ doc.title | default: doc.name | replace: '.md', '' | replace: '_', ' ' | capitalize }}
+                                </a>
+                            </li>
+                            {% endfor %}
+                        </ul>
+                    </nav>
+                </aside>
+                {% endif %}
+                
+                <!-- Page content -->
+                <div class="page-content">
+                    {% if page.title %}
+                    <header class="page-header">
+                        <h1 class="page-title">{{ page.title }}</h1>
+                        {% if page.description %}
+                        <p class="page-description">{{ page.description }}</p>
+                        {% endif %}
+                    </header>
+                    {% endif %}
+                    
+                    <div class="content">
+                        {{ content }}
+                    </div>
+                    
+                    <!-- Page navigation -->
+                    {% if page.collection == 'docs' %}
+                    <nav class="page-nav" aria-label="Page navigation">
+                        {% assign docs = site.docs | sort: 'order' %}
+                        {% for doc in docs %}
+                            {% if doc.url == page.url %}
+                                {% assign current_index = forloop.index0 %}
+                                {% break %}
+                            {% endif %}
+                        {% endfor %}
+                        
+                        {% if current_index > 0 %}
+                            {% assign prev_doc = docs[current_index | minus: 1] %}
+                            <a href="{{ prev_doc.url | relative_url }}" class="page-nav-link prev">
+                                <span class="nav-direction">← Previous</span>
+                                <span class="nav-title">{{ prev_doc.title | default: prev_doc.name | replace: '.md', '' }}</span>
+                            </a>
+                        {% endif %}
+                        
+                        {% assign next_index = current_index | plus: 1 %}
+                        {% if next_index < docs.size %}
+                            {% assign next_doc = docs[next_index] %}
+                            <a href="{{ next_doc.url | relative_url }}" class="page-nav-link next">
+                                <span class="nav-direction">Next →</span>
+                                <span class="nav-title">{{ next_doc.title | default: next_doc.name | replace: '.md', '' }}</span>
+                            </a>
+                        {% endif %}
+                    </nav>
+                    {% endif %}
+                </div>
+            </div>
+            {% endif %}
+        </div>
+    </main>
+    
+    <!-- Footer -->
+    <footer class="site-footer">
+        <div class="container">
+            <div class="footer-content">
+                <div class="footer-info">
+                    <p>&copy; {{ 'now' | date: '%Y' }} {{ site.author }}. Licensed under MIT.</p>
+                    <p>
+                        <a href="{{ site.github.repository_url }}" target="_blank" rel="noopener noreferrer">
+                            View on GitHub
+                        </a>
+                    </p>
+                </div>
+                
+                <div class="footer-links">
+                    <a href="{{ '/search' | relative_url }}">Search</a>
+                    <a href="{{ '/bookmarks' | relative_url }}">Bookmarks</a>
+                    <a href="{{ site.github.repository_url }}/issues" target="_blank" rel="noopener noreferrer">Report Issue</a>
+                </div>
+            </div>
+        </div>
+    </footer>
+    
+    <!-- JavaScript -->
+    <script src="{{ '/assets/js/main.js' | relative_url }}"></script>
+    
+    <!-- Search data for Lunr.js -->
+    <script>
+        window.searchData = [
+            {% for page in site.pages %}
+            {% unless page.url contains '/assets/' %}
+            {
+                "id": "{{ forloop.index0 }}",
+                "title": "{{ page.title | default: page.name | jsonify }}",
+                "content": {{ page.content | strip_html | strip_newlines | jsonify }},
+                "url": "{{ page.url | relative_url }}"
+            }{% unless forloop.last %},{% endunless %}
+            {% endunless %}
+            {% endfor %}
+            {% for doc in site.docs %}
+            ,{
+                "id": "{{ site.pages.size | plus: forloop.index0 }}",
+                "title": {{ doc.title | default: doc.name | jsonify }},
+                "content": {{ doc.content | strip_html | strip_newlines | jsonify }},
+                "url": "{{ doc.url | relative_url }}"
+            }{% unless forloop.last %},{% endunless %}
+            {% endfor %}
+        ];
+    </script>
+</body>
+</html>
\ No newline at end of file
diff --git a/_layouts/docs.html b/_layouts/docs.html
new file mode 100644
index 0000000..84f03f7
--- /dev/null
+++ b/_layouts/docs.html
@@ -0,0 +1,5 @@
+---
+layout: default
+---
+
+{{ content }}
\ No newline at end of file
diff --git a/_layouts/home.html b/_layouts/home.html
new file mode 100644
index 0000000..84f03f7
--- /dev/null
+++ b/_layouts/home.html
@@ -0,0 +1,5 @@
+---
+layout: default
+---
+
+{{ content }}
\ No newline at end of file
diff --git a/assets/css/main.css b/assets/css/main.css
new file mode 100644
index 0000000..1e458d4
--- /dev/null
+++ b/assets/css/main.css
@@ -0,0 +1,1136 @@
+/* 
+ * Solana MCP Server Documentation Site
+ * E-ink inspired grayscale theme with modern navigation
+ */
+
+/* CSS Custom Properties - E-ink Color Palette */
+:root {
+  /* E-ink grayscale palette */
+  --eink-white: #ffffff;
+  --eink-paper: #fafafa;
+  --eink-light-gray: #f5f5f5;
+  --eink-medium-gray: #e8e8e8;
+  --eink-dark-gray: #d0d0d0;
+  --eink-charcoal: #666666;
+  --eink-dark-charcoal: #444444;
+  --eink-black: #222222;
+  
+  /* Accent colors (minimal use) */
+  --accent-teal: #2d5f5f;
+  --accent-teal-light: #4a7a7a;
+  --accent-amber: #cc9900;
+  
+  /* Typography */
+  --font-family-sans: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+  --font-family-mono: 'JetBrains Mono', 'Fira Code', 'Consolas', monospace;
+  
+  /* Font weights */
+  --font-weight-light: 300;
+  --font-weight-normal: 400;
+  --font-weight-medium: 500;
+  --font-weight-semibold: 600;
+  --font-weight-bold: 700;
+  
+  /* Font sizes */
+  --font-size-xs: 0.75rem;
+  --font-size-sm: 0.875rem;
+  --font-size-base: 1rem;
+  --font-size-lg: 1.125rem;
+  --font-size-xl: 1.25rem;
+  --font-size-2xl: 1.5rem;
+  --font-size-3xl: 1.875rem;
+  --font-size-4xl: 2.25rem;
+  
+  /* Line heights */
+  --line-height-tight: 1.25;
+  --line-height-normal: 1.5;
+  --line-height-relaxed: 1.75;
+  
+  /* Spacing */
+  --spacing-xs: 0.25rem;
+  --spacing-sm: 0.5rem;
+  --spacing-md: 1rem;
+  --spacing-lg: 1.5rem;
+  --spacing-xl: 2rem;
+  --spacing-2xl: 3rem;
+  --spacing-3xl: 4rem;
+  
+  /* Layout */
+  --container-max-width: 1200px;
+  --sidebar-width: 280px;
+  --header-height: 72px;
+  
+  /* Borders and shadows */
+  --border-radius-sm: 4px;
+  --border-radius-md: 8px;
+  --border-radius-lg: 12px;
+  --border-width: 1px;
+  --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.05);
+  --shadow-md: 0 4px 6px rgba(0, 0, 0, 0.07);
+  --shadow-lg: 0 10px 15px rgba(0, 0, 0, 0.1);
+  
+  /* Transitions */
+  --transition-fast: 150ms ease-in-out;
+  --transition-normal: 250ms ease-in-out;
+  --transition-slow: 350ms ease-in-out;
+}
+
+/* Reset and base styles */
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+html {
+  font-size: 16px;
+  scroll-behavior: smooth;
+}
+
+body {
+  font-family: var(--font-family-sans);
+  font-weight: var(--font-weight-normal);
+  line-height: var(--line-height-normal);
+  color: var(--eink-black);
+  background-color: var(--eink-paper);
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+/* Skip link for accessibility */
+.skip-link {
+  position: absolute;
+  top: -40px;
+  left: 6px;
+  background: var(--eink-black);
+  color: var(--eink-white);
+  padding: var(--spacing-sm) var(--spacing-md);
+  text-decoration: none;
+  border-radius: var(--border-radius-sm);
+  z-index: 1000;
+  font-size: var(--font-size-sm);
+  font-weight: var(--font-weight-medium);
+}
+
+.skip-link:focus {
+  top: 6px;
+}
+
+/* Container */
+.container {
+  max-width: var(--container-max-width);
+  margin: 0 auto;
+  padding: 0 var(--spacing-md);
+}
+
+/* Header */
+.site-header {
+  background-color: var(--eink-white);
+  border-bottom: var(--border-width) solid var(--eink-medium-gray);
+  position: sticky;
+  top: 0;
+  z-index: 100;
+  height: var(--header-height);
+}
+
+.header-content {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  height: 100%;
+}
+
+.site-logo {
+  display: flex;
+  align-items: center;
+}
+
+.logo-link {
+  display: flex;
+  align-items: center;
+  text-decoration: none;
+  color: var(--eink-black);
+  font-weight: var(--font-weight-semibold);
+  gap: var(--spacing-sm);
+}
+
+.logo-image {
+  width: 32px;
+  height: 32px;
+}
+
+.site-title {
+  font-size: var(--font-size-lg);
+  font-weight: var(--font-weight-semibold);
+}
+
+/* Navigation */
+.main-nav {
+  display: flex;
+  align-items: center;
+}
+
+.nav-list {
+  display: flex;
+  list-style: none;
+  gap: var(--spacing-lg);
+  margin: 0;
+  padding: 0;
+}
+
+.nav-link {
+  text-decoration: none;
+  color: var(--eink-charcoal);
+  font-weight: var(--font-weight-medium);
+  font-size: var(--font-size-sm);
+  padding: var(--spacing-sm) var(--spacing-md);
+  border-radius: var(--border-radius-sm);
+  transition: all var(--transition-fast);
+  position: relative;
+}
+
+.nav-link:hover {
+  color: var(--eink-black);
+  background-color: var(--eink-light-gray);
+}
+
+.nav-link.active {
+  color: var(--accent-teal);
+  font-weight: var(--font-weight-semibold);
+}
+
+.nav-link.active::after {
+  content: '';
+  position: absolute;
+  bottom: -1px;
+  left: 50%;
+  transform: translateX(-50%);
+  width: 24px;
+  height: 2px;
+  background-color: var(--accent-teal);
+  border-radius: 1px;
+}
+
+/* Header utilities */
+.header-utilities {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-sm);
+}
+
+.search-toggle,
+.bookmark-toggle,
+.menu-toggle {
+  background: none;
+  border: none;
+  color: var(--eink-charcoal);
+  cursor: pointer;
+  padding: var(--spacing-sm);
+  border-radius: var(--border-radius-sm);
+  transition: all var(--transition-fast);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.search-toggle:hover,
+.bookmark-toggle:hover,
+.menu-toggle:hover {
+  background-color: var(--eink-light-gray);
+  color: var(--eink-black);
+}
+
+.bookmark-toggle.bookmarked {
+  color: var(--accent-amber);
+}
+
+.bookmark-toggle.bookmarked svg {
+  fill: currentColor;
+}
+
+/* Menu toggle (hamburger) */
+.menu-toggle {
+  display: none;
+  flex-direction: column;
+  width: 24px;
+  height: 24px;
+}
+
+.menu-bar {
+  width: 100%;
+  height: 2px;
+  background-color: currentColor;
+  margin: 2px 0;
+  transition: all var(--transition-fast);
+}
+
+.menu-toggle[aria-expanded="true"] .menu-bar:nth-child(1) {
+  transform: rotate(45deg) translate(5px, 5px);
+}
+
+.menu-toggle[aria-expanded="true"] .menu-bar:nth-child(2) {
+  opacity: 0;
+}
+
+.menu-toggle[aria-expanded="true"] .menu-bar:nth-child(3) {
+  transform: rotate(-45deg) translate(7px, -6px);
+}
+
+/* Search overlay */
+.search-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background-color: rgba(0, 0, 0, 0.5);
+  backdrop-filter: blur(4px);
+  z-index: 200;
+  opacity: 0;
+  visibility: hidden;
+  transition: all var(--transition-normal);
+}
+
+.search-overlay.active {
+  opacity: 1;
+  visibility: visible;
+}
+
+.search-container {
+  position: absolute;
+  top: 20%;
+  left: 50%;
+  transform: translateX(-50%);
+  width: 90%;
+  max-width: 600px;
+  background-color: var(--eink-white);
+  border-radius: var(--border-radius-lg);
+  box-shadow: var(--shadow-lg);
+  overflow: hidden;
+}
+
+.search-input-wrapper {
+  position: relative;
+  padding: var(--spacing-lg);
+  border-bottom: var(--border-width) solid var(--eink-medium-gray);
+}
+
+#search-input {
+  width: 100%;
+  background: none;
+  border: none;
+  font-size: var(--font-size-lg);
+  color: var(--eink-black);
+  outline: none;
+  font-family: inherit;
+}
+
+#search-input::placeholder {
+  color: var(--eink-charcoal);
+}
+
+.search-close {
+  position: absolute;
+  top: 50%;
+  right: var(--spacing-lg);
+  transform: translateY(-50%);
+  background: none;
+  border: none;
+  font-size: var(--font-size-2xl);
+  color: var(--eink-charcoal);
+  cursor: pointer;
+  width: 32px;
+  height: 32px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: var(--border-radius-sm);
+  transition: all var(--transition-fast);
+}
+
+.search-close:hover {
+  background-color: var(--eink-light-gray);
+  color: var(--eink-black);
+}
+
+.search-results {
+  max-height: 400px;
+  overflow-y: auto;
+}
+
+.search-result {
+  padding: var(--spacing-md) var(--spacing-lg);
+  border-bottom: var(--border-width) solid var(--eink-light-gray);
+  cursor: pointer;
+  transition: background-color var(--transition-fast);
+}
+
+.search-result:hover {
+  background-color: var(--eink-light-gray);
+}
+
+.search-result:last-child {
+  border-bottom: none;
+}
+
+.search-result-title {
+  font-weight: var(--font-weight-semibold);
+  margin-bottom: var(--spacing-xs);
+  color: var(--eink-black);
+}
+
+.search-result-snippet {
+  font-size: var(--font-size-sm);
+  color: var(--eink-charcoal);
+  line-height: var(--line-height-relaxed);
+}
+
+/* Main content */
+.main-content {
+  min-height: calc(100vh - var(--header-height) - 120px);
+  padding: var(--spacing-xl) 0;
+}
+
+.content-layout {
+  display: flex;
+  gap: var(--spacing-2xl);
+  align-items: flex-start;
+}
+
+/* Sidebar */
+.sidebar {
+  flex: 0 0 var(--sidebar-width);
+  position: sticky;
+  top: calc(var(--header-height) + var(--spacing-xl));
+}
+
+.docs-nav {
+  background-color: var(--eink-white);
+  border: var(--border-width) solid var(--eink-medium-gray);
+  border-radius: var(--border-radius-md);
+  padding: var(--spacing-lg);
+}
+
+.docs-nav-title {
+  font-size: var(--font-size-lg);
+  font-weight: var(--font-weight-semibold);
+  margin-bottom: var(--spacing-lg);
+  color: var(--eink-black);
+}
+
+.docs-nav-list {
+  list-style: none;
+}
+
+.docs-nav-category {
+  margin-bottom: var(--spacing-lg);
+}
+
+.category-title {
+  font-size: var(--font-size-sm);
+  font-weight: var(--font-weight-semibold);
+  color: var(--accent-teal);
+  margin-bottom: var(--spacing-xs);
+}
+
+.category-description {
+  font-size: var(--font-size-xs);
+  color: var(--eink-charcoal);
+  margin-bottom: var(--spacing-md);
+  line-height: var(--line-height-relaxed);
+}
+
+.docs-nav-item {
+  margin-bottom: var(--spacing-xs);
+}
+
+.docs-nav-link {
+  display: block;
+  text-decoration: none;
+  color: var(--eink-charcoal);
+  font-size: var(--font-size-sm);
+  padding: var(--spacing-sm);
+  border-radius: var(--border-radius-sm);
+  transition: all var(--transition-fast);
+}
+
+.docs-nav-link:hover {
+  background-color: var(--eink-light-gray);
+  color: var(--eink-black);
+}
+
+.docs-nav-link.active {
+  background-color: var(--accent-teal);
+  color: var(--eink-white);
+  font-weight: var(--font-weight-medium);
+}
+
+/* Page content */
+.page-content {
+  flex: 1;
+  min-width: 0;
+}
+
+.page-header {
+  margin-bottom: var(--spacing-2xl);
+  padding-bottom: var(--spacing-lg);
+  border-bottom: var(--border-width) solid var(--eink-medium-gray);
+}
+
+.page-title {
+  font-size: var(--font-size-3xl);
+  font-weight: var(--font-weight-bold);
+  line-height: var(--line-height-tight);
+  margin-bottom: var(--spacing-md);
+  color: var(--eink-black);
+}
+
+.page-description {
+  font-size: var(--font-size-lg);
+  color: var(--eink-charcoal);
+  line-height: var(--line-height-relaxed);
+}
+
+/* Content typography */
+.content {
+  line-height: var(--line-height-relaxed);
+}
+
+.content h1,
+.content h2,
+.content h3,
+.content h4,
+.content h5,
+.content h6 {
+  font-weight: var(--font-weight-semibold);
+  line-height: var(--line-height-tight);
+  margin-top: var(--spacing-2xl);
+  margin-bottom: var(--spacing-md);
+  color: var(--eink-black);
+}
+
+.content h1 {
+  font-size: var(--font-size-3xl);
+  border-bottom: var(--border-width) solid var(--eink-medium-gray);
+  padding-bottom: var(--spacing-sm);
+}
+
+.content h2 {
+  font-size: var(--font-size-2xl);
+}
+
+.content h3 {
+  font-size: var(--font-size-xl);
+}
+
+.content h4 {
+  font-size: var(--font-size-lg);
+}
+
+.content h5,
+.content h6 {
+  font-size: var(--font-size-base);
+}
+
+.content p {
+  margin-bottom: var(--spacing-md);
+  color: var(--eink-dark-charcoal);
+}
+
+.content a {
+  color: var(--accent-teal);
+  text-decoration: underline;
+  text-decoration-color: var(--eink-dark-gray);
+  text-underline-offset: 2px;
+  transition: all var(--transition-fast);
+}
+
+.content a:hover {
+  color: var(--accent-teal-light);
+  text-decoration-color: var(--accent-teal-light);
+}
+
+.content ul,
+.content ol {
+  margin-bottom: var(--spacing-md);
+  padding-left: var(--spacing-lg);
+}
+
+.content li {
+  margin-bottom: var(--spacing-xs);
+  color: var(--eink-dark-charcoal);
+}
+
+.content li::marker {
+  color: var(--eink-charcoal);
+}
+
+.content blockquote {
+  margin: var(--spacing-lg) 0;
+  padding: var(--spacing-md) var(--spacing-lg);
+  background-color: var(--eink-light-gray);
+  border-left: 4px solid var(--accent-teal);
+  border-radius: 0 var(--border-radius-sm) var(--border-radius-sm) 0;
+}
+
+.content blockquote p {
+  margin-bottom: 0;
+  font-style: italic;
+  color: var(--eink-charcoal);
+}
+
+/* Code blocks */
+.content pre,
+.content code {
+  font-family: var(--font-family-mono);
+  font-size: var(--font-size-sm);
+}
+
+.content code {
+  background-color: var(--eink-light-gray);
+  padding: 2px 6px;
+  border-radius: var(--border-radius-sm);
+  color: var(--eink-black);
+}
+
+.content pre {
+  background-color: var(--eink-white);
+  border: var(--border-width) solid var(--eink-medium-gray);
+  border-radius: var(--border-radius-md);
+  padding: var(--spacing-lg);
+  margin: var(--spacing-lg) 0;
+  overflow-x: auto;
+  line-height: var(--line-height-normal);
+}
+
+.content pre code {
+  background: none;
+  padding: 0;
+  border-radius: 0;
+  color: var(--eink-dark-charcoal);
+}
+
+/* Tables */
+.content table {
+  width: 100%;
+  border-collapse: collapse;
+  margin: var(--spacing-lg) 0;
+  background-color: var(--eink-white);
+  border: var(--border-width) solid var(--eink-medium-gray);
+  border-radius: var(--border-radius-md);
+  overflow: hidden;
+}
+
+.content th,
+.content td {
+  padding: var(--spacing-md);
+  text-align: left;
+  border-bottom: var(--border-width) solid var(--eink-light-gray);
+}
+
+.content th {
+  background-color: var(--eink-light-gray);
+  font-weight: var(--font-weight-semibold);
+  color: var(--eink-black);
+}
+
+.content td {
+  color: var(--eink-dark-charcoal);
+}
+
+.content tr:last-child td {
+  border-bottom: none;
+}
+
+/* Page navigation */
+.page-nav {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  margin-top: var(--spacing-3xl);
+  padding-top: var(--spacing-xl);
+  border-top: var(--border-width) solid var(--eink-medium-gray);
+  gap: var(--spacing-lg);
+}
+
+.page-nav-link {
+  display: flex;
+  flex-direction: column;
+  text-decoration: none;
+  padding: var(--spacing-md);
+  border: var(--border-width) solid var(--eink-medium-gray);
+  border-radius: var(--border-radius-md);
+  background-color: var(--eink-white);
+  transition: all var(--transition-fast);
+  flex: 1;
+  max-width: 300px;
+}
+
+.page-nav-link:hover {
+  border-color: var(--accent-teal);
+  box-shadow: var(--shadow-sm);
+}
+
+.page-nav-link.prev {
+  text-align: left;
+}
+
+.page-nav-link.next {
+  text-align: right;
+  margin-left: auto;
+}
+
+.nav-direction {
+  font-size: var(--font-size-xs);
+  color: var(--eink-charcoal);
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+  font-weight: var(--font-weight-medium);
+  margin-bottom: var(--spacing-xs);
+}
+
+.nav-title {
+  font-size: var(--font-size-sm);
+  color: var(--eink-black);
+  font-weight: var(--font-weight-medium);
+}
+
+/* Footer */
+.site-footer {
+  background-color: var(--eink-white);
+  border-top: var(--border-width) solid var(--eink-medium-gray);
+  padding: var(--spacing-xl) 0;
+  margin-top: var(--spacing-3xl);
+}
+
+.footer-content {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: var(--spacing-md);
+}
+
+.footer-info {
+  font-size: var(--font-size-sm);
+  color: var(--eink-charcoal);
+}
+
+.footer-info a {
+  color: var(--accent-teal);
+  text-decoration: none;
+}
+
+.footer-info a:hover {
+  text-decoration: underline;
+}
+
+.footer-links {
+  display: flex;
+  gap: var(--spacing-lg);
+}
+
+.footer-links a {
+  font-size: var(--font-size-sm);
+  color: var(--eink-charcoal);
+  text-decoration: none;
+  font-weight: var(--font-weight-medium);
+}
+
+.footer-links a:hover {
+  color: var(--eink-black);
+  text-decoration: underline;
+}
+
+/* Home page specific styles */
+.hero-section {
+  text-align: center;
+  padding: var(--spacing-3xl) 0;
+  margin-bottom: var(--spacing-3xl);
+}
+
+.hero-title {
+  font-size: var(--font-size-4xl);
+  font-weight: var(--font-weight-bold);
+  line-height: var(--line-height-tight);
+  margin-bottom: var(--spacing-lg);
+  color: var(--eink-black);
+}
+
+.hero-subtitle {
+  font-size: var(--font-size-xl);
+  color: var(--eink-charcoal);
+  line-height: var(--line-height-relaxed);
+  margin-bottom: var(--spacing-xl);
+  max-width: 600px;
+  margin-left: auto;
+  margin-right: auto;
+}
+
+.hero-actions {
+  display: flex;
+  gap: var(--spacing-md);
+  justify-content: center;
+  flex-wrap: wrap;
+}
+
+.btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding: var(--spacing-md) var(--spacing-xl);
+  border: var(--border-width) solid var(--eink-medium-gray);
+  border-radius: var(--border-radius-md);
+  text-decoration: none;
+  font-weight: var(--font-weight-medium);
+  font-size: var(--font-size-base);
+  transition: all var(--transition-fast);
+  cursor: pointer;
+  background-color: var(--eink-white);
+  color: var(--eink-black);
+}
+
+.btn:hover {
+  border-color: var(--accent-teal);
+  box-shadow: var(--shadow-sm);
+}
+
+.btn-primary {
+  background-color: var(--accent-teal);
+  color: var(--eink-white);
+  border-color: var(--accent-teal);
+}
+
+.btn-primary:hover {
+  background-color: var(--accent-teal-light);
+  border-color: var(--accent-teal-light);
+}
+
+/* Feature grid */
+.features-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+  gap: var(--spacing-xl);
+  margin: var(--spacing-3xl) 0;
+}
+
+.feature-card {
+  background-color: var(--eink-white);
+  border: var(--border-width) solid var(--eink-medium-gray);
+  border-radius: var(--border-radius-lg);
+  padding: var(--spacing-xl);
+  transition: all var(--transition-fast);
+}
+
+.feature-card:hover {
+  border-color: var(--accent-teal);
+  box-shadow: var(--shadow-md);
+}
+
+.feature-icon {
+  font-size: var(--font-size-3xl);
+  margin-bottom: var(--spacing-md);
+  display: block;
+}
+
+.feature-title {
+  font-size: var(--font-size-xl);
+  font-weight: var(--font-weight-semibold);
+  margin-bottom: var(--spacing-md);
+  color: var(--eink-black);
+}
+
+.feature-description {
+  color: var(--eink-charcoal);
+  line-height: var(--line-height-relaxed);
+}
+
+/* Documentation grid */
+.docs-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+  gap: var(--spacing-lg);
+  margin: var(--spacing-2xl) 0;
+}
+
+.docs-card {
+  background-color: var(--eink-white);
+  border: var(--border-width) solid var(--eink-medium-gray);
+  border-radius: var(--border-radius-md);
+  padding: var(--spacing-lg);
+  text-decoration: none;
+  color: inherit;
+  transition: all var(--transition-fast);
+  display: block;
+}
+
+.docs-card:hover {
+  border-color: var(--accent-teal);
+  box-shadow: var(--shadow-sm);
+  text-decoration: none;
+}
+
+.docs-card-icon {
+  font-size: var(--font-size-2xl);
+  margin-bottom: var(--spacing-sm);
+  display: block;
+}
+
+.docs-card-title {
+  font-size: var(--font-size-lg);
+  font-weight: var(--font-weight-semibold);
+  margin-bottom: var(--spacing-sm);
+  color: var(--eink-black);
+}
+
+.docs-card-description {
+  font-size: var(--font-size-sm);
+  color: var(--eink-charcoal);
+  line-height: var(--line-height-relaxed);
+}
+
+/* Responsive design */
+@media (max-width: 768px) {
+  :root {
+    --container-max-width: 100%;
+    --sidebar-width: 100%;
+  }
+  
+  .container {
+    padding: 0 var(--spacing-sm);
+  }
+  
+  .header-content {
+    position: relative;
+  }
+  
+  .main-nav {
+    display: none;
+    position: absolute;
+    top: 100%;
+    left: 0;
+    right: 0;
+    background-color: var(--eink-white);
+    border-top: var(--border-width) solid var(--eink-medium-gray);
+    z-index: 50;
+  }
+  
+  .main-nav.active {
+    display: block;
+  }
+  
+  .nav-list {
+    flex-direction: column;
+    gap: 0;
+    padding: var(--spacing-md);
+  }
+  
+  .nav-link {
+    display: block;
+    padding: var(--spacing-md);
+    border-bottom: var(--border-width) solid var(--eink-light-gray);
+  }
+  
+  .nav-link:last-child {
+    border-bottom: none;
+  }
+  
+  .menu-toggle {
+    display: flex;
+  }
+  
+  .content-layout {
+    flex-direction: column;
+    gap: var(--spacing-xl);
+  }
+  
+  .sidebar {
+    position: static;
+    order: 2;
+  }
+  
+  .page-content {
+    order: 1;
+  }
+  
+  .page-nav {
+    flex-direction: column;
+    gap: var(--spacing-md);
+  }
+  
+  .page-nav-link {
+    max-width: none;
+    margin-left: 0;
+  }
+  
+  .hero-title {
+    font-size: var(--font-size-3xl);
+  }
+  
+  .hero-subtitle {
+    font-size: var(--font-size-lg);
+  }
+  
+  .hero-actions {
+    flex-direction: column;
+    align-items: center;
+  }
+  
+  .btn {
+    width: 100%;
+    max-width: 280px;
+  }
+  
+  .features-grid {
+    grid-template-columns: 1fr;
+  }
+  
+  .docs-grid {
+    grid-template-columns: 1fr;
+  }
+  
+  .footer-content {
+    flex-direction: column;
+    text-align: center;
+    gap: var(--spacing-lg);
+  }
+}
+
+@media (max-width: 480px) {
+  .container {
+    padding: 0 var(--spacing-xs);
+  }
+  
+  .site-header {
+    height: 60px;
+  }
+  
+  .site-title {
+    font-size: var(--font-size-base);
+  }
+  
+  .search-container {
+    width: 95%;
+  }
+  
+  .main-content {
+    padding: var(--spacing-lg) 0;
+  }
+  
+  .page-title {
+    font-size: var(--font-size-2xl);
+  }
+  
+  .feature-card,
+  .docs-card {
+    padding: var(--spacing-md);
+  }
+}
+
+/* Print styles */
+@media print {
+  .site-header,
+  .sidebar,
+  .page-nav,
+  .site-footer,
+  .search-overlay {
+    display: none !important;
+  }
+  
+  .main-content {
+    padding: 0;
+  }
+  
+  .content-layout {
+    flex-direction: column;
+  }
+  
+  .page-content {
+    width: 100%;
+  }
+  
+  body {
+    background: white;
+    color: black;
+  }
+  
+  a {
+    color: black;
+    text-decoration: underline;
+  }
+}
+
+/* Accessibility enhancements */
+@media (prefers-reduced-motion: reduce) {
+  * {
+    animation-duration: 0.01ms !important;
+    animation-iteration-count: 1 !important;
+    transition-duration: 0.01ms !important;
+    scroll-behavior: auto !important;
+  }
+}
+
+/* High contrast mode support */
+@media (prefers-contrast: high) {
+  :root {
+    --eink-white: #ffffff;
+    --eink-paper: #ffffff;
+    --eink-light-gray: #f0f0f0;
+    --eink-medium-gray: #cccccc;
+    --eink-dark-gray: #999999;
+    --eink-charcoal: #333333;
+    --eink-dark-charcoal: #222222;
+    --eink-black: #000000;
+    --accent-teal: #000080;
+    --accent-teal-light: #000080;
+  }
+  
+  .content a {
+    text-decoration: underline;
+    text-decoration-thickness: 2px;
+  }
+  
+  .btn {
+    border-width: 2px;
+  }
+}
+
+/* Focus indicators */
+button:focus,
+a:focus,
+input:focus,
+select:focus,
+textarea:focus {
+  outline: 2px solid var(--accent-teal);
+  outline-offset: 2px;
+}
+
+/* Loading states and animations */
+@keyframes pulse {
+  0%, 100% {
+    opacity: 1;
+  }
+  50% {
+    opacity: 0.5;
+  }
+}
+
+.loading {
+  animation: pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite;
+}
+
+/* Syntax highlighting (Rouge) */
+.highlight {
+  background-color: var(--eink-white);
+  border: var(--border-width) solid var(--eink-medium-gray);
+  border-radius: var(--border-radius-md);
+  padding: var(--spacing-lg);
+  margin: var(--spacing-lg) 0;
+  overflow-x: auto;
+}
+
+.highlight .c { color: var(--eink-charcoal); font-style: italic; } /* Comment */
+.highlight .k { color: var(--accent-teal); font-weight: bold; } /* Keyword */
+.highlight .s { color: var(--accent-amber); } /* String */
+.highlight .nb { color: var(--accent-teal); } /* Name.Builtin */
+.highlight .nf { color: var(--eink-dark-charcoal); font-weight: bold; } /* Name.Function */
\ No newline at end of file
diff --git a/assets/images/favicon.svg b/assets/images/favicon.svg
new file mode 100644
index 0000000..dec58fe
--- /dev/null
+++ b/assets/images/favicon.svg
@@ -0,0 +1,12 @@
+<svg width="32" height="32" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <rect width="32" height="32" rx="6" fill="#2d5f5f"/>
+  <circle cx="8" cy="8" r="3" fill="#ffffff" opacity="0.9"/>
+  <circle cx="24" cy="8" r="3" fill="#ffffff" opacity="0.7"/>
+  <circle cx="16" cy="16" r="4" fill="#ffffff"/>
+  <circle cx="8" cy="24" r="3" fill="#ffffff" opacity="0.7"/>
+  <circle cx="24" cy="24" r="3" fill="#ffffff" opacity="0.9"/>
+  <path d="M11 8 L21 8" stroke="#ffffff" stroke-width="1" opacity="0.5"/>
+  <path d="M16 12 L16 20" stroke="#ffffff" stroke-width="1" opacity="0.5"/>
+  <path d="M11 24 L21 24" stroke="#ffffff" stroke-width="1" opacity="0.5"/>
+  <text x="16" y="19" text-anchor="middle" font-family="Arial, sans-serif" font-size="6" font-weight="bold" fill="#2d5f5f">M</text>
+</svg>
\ No newline at end of file
diff --git a/assets/images/logo.svg b/assets/images/logo.svg
new file mode 100644
index 0000000..7ec0b9f
--- /dev/null
+++ b/assets/images/logo.svg
@@ -0,0 +1,22 @@
+<svg width="48" height="48" viewBox="0 0 48 48" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <!-- Solana-inspired gradient circles representing blockchain nodes -->
+  <circle cx="12" cy="12" r="6" fill="#2d5f5f" opacity="0.8"/>
+  <circle cx="36" cy="12" r="6" fill="#4a7a7a" opacity="0.7"/>
+  <circle cx="24" cy="24" r="8" fill="#2d5f5f"/>
+  <circle cx="12" cy="36" r="6" fill="#4a7a7a" opacity="0.7"/>
+  <circle cx="36" cy="36" r="6" fill="#2d5f5f" opacity="0.8"/>
+  
+  <!-- Connection lines representing network -->
+  <path d="M18 12 L30 12" stroke="#666666" stroke-width="2" opacity="0.6"/>
+  <path d="M24 16 L24 20" stroke="#666666" stroke-width="2" opacity="0.6"/>
+  <path d="M18 36 L30 36" stroke="#666666" stroke-width="2" opacity="0.6"/>
+  <path d="M24 28 L24 32" stroke="#666666" stroke-width="2" opacity="0.6"/>
+  <path d="M18 18 L20 20" stroke="#666666" stroke-width="2" opacity="0.6"/>
+  <path d="M30 18 L28 20" stroke="#666666" stroke-width="2" opacity="0.6"/>
+  <path d="M18 30 L20 28" stroke="#666666" stroke-width="2" opacity="0.6"/>
+  <path d="M30 30 L28 28" stroke="#666666" stroke-width="2" opacity="0.6"/>
+  
+  <!-- Central MCP indicator -->
+  <circle cx="24" cy="24" r="4" fill="#ffffff" stroke="#2d5f5f" stroke-width="2"/>
+  <text x="24" y="28" text-anchor="middle" font-family="Arial, sans-serif" font-size="8" font-weight="bold" fill="#2d5f5f">M</text>
+</svg>
\ No newline at end of file
diff --git a/assets/js/main.js b/assets/js/main.js
new file mode 100644
index 0000000..bfc6f47
--- /dev/null
+++ b/assets/js/main.js
@@ -0,0 +1,566 @@
+/**
+ * Solana MCP Server Documentation Site
+ * JavaScript for search, bookmarks, and navigation
+ */
+
+(function() {
+    'use strict';
+
+    // Initialize when DOM is ready
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else {
+        init();
+    }
+
+    function init() {
+        initializeSearch();
+        initializeBookmarks();
+        initializeNavigation();
+        initializeScrollSpy();
+        initializeTableOfContents();
+    }
+
+    // Search functionality
+    function initializeSearch() {
+        const searchToggle = document.getElementById('search-toggle');
+        const searchOverlay = document.getElementById('search-overlay');
+        const searchInput = document.getElementById('search-input');
+        const searchClose = document.getElementById('search-close');
+        const searchResults = document.getElementById('search-results');
+
+        if (!searchToggle || !searchOverlay || !searchInput) return;
+
+        let searchIndex;
+        let searchData = [];
+
+        // Initialize Lunr search index
+        if (window.searchData) {
+            searchData = window.searchData;
+            searchIndex = lunr(function() {
+                this.ref('id');
+                this.field('title', { boost: 10 });
+                this.field('content');
+
+                searchData.forEach((doc) => {
+                    this.add(doc);
+                });
+            });
+        }
+
+        // Toggle search overlay
+        searchToggle.addEventListener('click', () => {
+            searchOverlay.classList.add('active');
+            searchInput.focus();
+            searchToggle.setAttribute('aria-expanded', 'true');
+        });
+
+        // Close search overlay
+        function closeSearch() {
+            searchOverlay.classList.remove('active');
+            searchInput.value = '';
+            searchResults.innerHTML = '';
+            searchToggle.setAttribute('aria-expanded', 'false');
+        }
+
+        searchClose.addEventListener('click', closeSearch);
+
+        // Close on escape key
+        searchOverlay.addEventListener('keydown', (e) => {
+            if (e.key === 'Escape') {
+                closeSearch();
+            }
+        });
+
+        // Close on overlay click
+        searchOverlay.addEventListener('click', (e) => {
+            if (e.target === searchOverlay) {
+                closeSearch();
+            }
+        });
+
+        // Search input handler
+        let searchTimeout;
+        searchInput.addEventListener('input', (e) => {
+            clearTimeout(searchTimeout);
+            const query = e.target.value.trim();
+
+            if (query.length < 2) {
+                searchResults.innerHTML = '';
+                return;
+            }
+
+            searchTimeout = setTimeout(() => {
+                performSearch(query);
+            }, 150);
+        });
+
+        function performSearch(query) {
+            if (!searchIndex) {
+                searchResults.innerHTML = '<div class="search-result"><div class="search-result-title">Search not available</div></div>';
+                return;
+            }
+
+            try {
+                const results = searchIndex.search(query);
+                displaySearchResults(results, query);
+            } catch (e) {
+                console.error('Search error:', e);
+                searchResults.innerHTML = '<div class="search-result"><div class="search-result-title">Search error occurred</div></div>';
+            }
+        }
+
+        function displaySearchResults(results, query) {
+            if (results.length === 0) {
+                searchResults.innerHTML = '<div class="search-result"><div class="search-result-title">No results found</div></div>';
+                return;
+            }
+
+            const html = results.slice(0, 8).map(result => {
+                const doc = searchData.find(d => d.id === result.ref);
+                if (!doc) return '';
+
+                const title = highlightMatch(doc.title, query);
+                const snippet = generateSnippet(doc.content, query);
+
+                return `
+                    <div class="search-result" onclick="navigateToResult('${doc.url}')">
+                        <div class="search-result-title">${title}</div>
+                        <div class="search-result-snippet">${snippet}</div>
+                    </div>
+                `;
+            }).join('');
+
+            searchResults.innerHTML = html;
+        }
+
+        function highlightMatch(text, query) {
+            const regex = new RegExp(`(${escapeRegex(query)})`, 'gi');
+            return text.replace(regex, '<mark>$1</mark>');
+        }
+
+        function generateSnippet(content, query, length = 150) {
+            const words = content.toLowerCase().split(/\s+/);
+            const queryWords = query.toLowerCase().split(/\s+/);
+            
+            let bestIndex = 0;
+            let bestScore = 0;
+
+            // Find the best position to show snippet
+            for (let i = 0; i < words.length - 10; i++) {
+                let score = 0;
+                for (let j = i; j < Math.min(i + 20, words.length); j++) {
+                    if (queryWords.some(qw => words[j].includes(qw))) {
+                        score += 1;
+                    }
+                }
+                if (score > bestScore) {
+                    bestScore = score;
+                    bestIndex = i;
+                }
+            }
+
+            const snippetWords = content.split(/\s+/).slice(bestIndex, bestIndex + 25);
+            let snippet = snippetWords.join(' ');
+            
+            if (snippet.length > length) {
+                snippet = snippet.substring(0, length) + '...';
+            }
+            
+            return highlightMatch(snippet, query);
+        }
+
+        function escapeRegex(string) {
+            return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        }
+
+        // Make navigateToResult globally available
+        window.navigateToResult = function(url) {
+            window.location.href = url;
+        };
+    }
+
+    // Bookmark functionality
+    function initializeBookmarks() {
+        const bookmarkToggle = document.getElementById('bookmark-toggle');
+        if (!bookmarkToggle) return;
+
+        const currentUrl = window.location.pathname;
+        const currentTitle = bookmarkToggle.getAttribute('data-title');
+
+        // Check if current page is bookmarked
+        updateBookmarkIcon();
+
+        bookmarkToggle.addEventListener('click', () => {
+            toggleBookmark(currentUrl, currentTitle);
+        });
+
+        function toggleBookmark(url, title) {
+            let bookmarks = JSON.parse(localStorage.getItem('solana-mcp-bookmarks') || '[]');
+            const existingIndex = bookmarks.findIndex(b => b.url === url);
+
+            if (existingIndex > -1) {
+                // Remove bookmark
+                bookmarks.splice(existingIndex, 1);
+                bookmarkToggle.classList.remove('bookmarked');
+                bookmarkToggle.setAttribute('aria-label', 'Bookmark this page');
+            } else {
+                // Add bookmark
+                bookmarks.push({
+                    url: url,
+                    title: title,
+                    timestamp: Date.now()
+                });
+                bookmarkToggle.classList.add('bookmarked');
+                bookmarkToggle.setAttribute('aria-label', 'Remove bookmark');
+            }
+
+            localStorage.setItem('solana-mcp-bookmarks', JSON.stringify(bookmarks));
+            window.bookmarks = bookmarks;
+        }
+
+        function updateBookmarkIcon() {
+            const bookmarks = JSON.parse(localStorage.getItem('solana-mcp-bookmarks') || '[]');
+            const isBookmarked = bookmarks.some(b => b.url === currentUrl);
+            
+            if (isBookmarked) {
+                bookmarkToggle.classList.add('bookmarked');
+                bookmarkToggle.setAttribute('aria-label', 'Remove bookmark');
+            } else {
+                bookmarkToggle.classList.remove('bookmarked');
+                bookmarkToggle.setAttribute('aria-label', 'Bookmark this page');
+            }
+        }
+    }
+
+    // Navigation functionality
+    function initializeNavigation() {
+        const menuToggle = document.getElementById('menu-toggle');
+        const mainNav = document.querySelector('.main-nav');
+        
+        if (!menuToggle || !mainNav) return;
+
+        menuToggle.addEventListener('click', () => {
+            const isExpanded = menuToggle.getAttribute('aria-expanded') === 'true';
+            
+            menuToggle.setAttribute('aria-expanded', !isExpanded);
+            mainNav.classList.toggle('active');
+        });
+
+        // Close menu when clicking outside
+        document.addEventListener('click', (e) => {
+            if (!menuToggle.contains(e.target) && !mainNav.contains(e.target)) {
+                menuToggle.setAttribute('aria-expanded', 'false');
+                mainNav.classList.remove('active');
+            }
+        });
+
+        // Close menu on escape key
+        document.addEventListener('keydown', (e) => {
+            if (e.key === 'Escape') {
+                menuToggle.setAttribute('aria-expanded', 'false');
+                mainNav.classList.remove('active');
+            }
+        });
+
+        // Handle responsive navigation
+        window.addEventListener('resize', () => {
+            if (window.innerWidth > 768) {
+                menuToggle.setAttribute('aria-expanded', 'false');
+                mainNav.classList.remove('active');
+            }
+        });
+    }
+
+    // Scroll spy for documentation navigation
+    function initializeScrollSpy() {
+        const headings = document.querySelectorAll('.content h1, .content h2, .content h3');
+        const navLinks = document.querySelectorAll('.docs-nav-link');
+        
+        if (headings.length === 0 || navLinks.length === 0) return;
+
+        const observer = new IntersectionObserver((entries) => {
+            entries.forEach(entry => {
+                if (entry.isIntersecting) {
+                    const id = entry.target.id;
+                    if (id) {
+                        // Update active navigation link
+                        navLinks.forEach(link => {
+                            link.classList.remove('active');
+                            if (link.getAttribute('href').includes(id)) {
+                                link.classList.add('active');
+                            }
+                        });
+                    }
+                }
+            });
+        }, {
+            rootMargin: '-20% 0px -70% 0px'
+        });
+
+        headings.forEach(heading => {
+            if (heading.id) {
+                observer.observe(heading);
+            }
+        });
+    }
+
+    // Generate table of contents for long documents
+    function initializeTableOfContents() {
+        const content = document.querySelector('.content');
+        if (!content) return;
+
+        const headings = content.querySelectorAll('h2, h3, h4');
+        if (headings.length < 3) return; // Only show TOC for documents with multiple headings
+
+        const toc = document.createElement('div');
+        toc.className = 'table-of-contents';
+        toc.innerHTML = '<h3>Table of Contents</h3>';
+
+        const tocNav = document.createElement('nav');
+        tocNav.setAttribute('aria-label', 'Table of contents');
+        
+        const tocList = document.createElement('ul');
+        tocList.className = 'toc-list';
+
+        headings.forEach((heading, index) => {
+            // Generate ID if it doesn't exist
+            if (!heading.id) {
+                heading.id = `heading-${index}`;
+            }
+
+            const li = document.createElement('li');
+            li.className = `toc-item toc-${heading.tagName.toLowerCase()}`;
+            
+            const link = document.createElement('a');
+            link.href = `#${heading.id}`;
+            link.textContent = heading.textContent;
+            link.className = 'toc-link';
+            
+            // Smooth scroll to heading
+            link.addEventListener('click', (e) => {
+                e.preventDefault();
+                heading.scrollIntoView({
+                    behavior: 'smooth',
+                    block: 'start'
+                });
+                
+                // Update URL without triggering page reload
+                history.pushState(null, null, `#${heading.id}`);
+            });
+            
+            li.appendChild(link);
+            tocList.appendChild(li);
+        });
+
+        tocNav.appendChild(tocList);
+        toc.appendChild(tocNav);
+
+        // Insert TOC after the first paragraph or at the beginning
+        const firstParagraph = content.querySelector('p');
+        if (firstParagraph) {
+            firstParagraph.parentNode.insertBefore(toc, firstParagraph.nextSibling);
+        } else {
+            content.insertBefore(toc, content.firstChild);
+        }
+    }
+
+    // Utility functions
+    function debounce(func, wait) {
+        let timeout;
+        return function executedFunction(...args) {
+            const later = () => {
+                clearTimeout(timeout);
+                func(...args);
+            };
+            clearTimeout(timeout);
+            timeout = setTimeout(later, wait);
+        };
+    }
+
+    function throttle(func, limit) {
+        let inThrottle;
+        return function() {
+            const args = arguments;
+            const context = this;
+            if (!inThrottle) {
+                func.apply(context, args);
+                inThrottle = true;
+                setTimeout(() => inThrottle = false, limit);
+            }
+        };
+    }
+
+    // Copy code functionality
+    function initializeCodeCopy() {
+        const codeBlocks = document.querySelectorAll('pre code');
+        
+        codeBlocks.forEach(block => {
+            const button = document.createElement('button');
+            button.className = 'copy-code-btn';
+            button.textContent = 'Copy';
+            button.setAttribute('aria-label', 'Copy code to clipboard');
+            
+            button.addEventListener('click', async () => {
+                try {
+                    await navigator.clipboard.writeText(block.textContent);
+                    button.textContent = 'Copied!';
+                    button.classList.add('copied');
+                    
+                    setTimeout(() => {
+                        button.textContent = 'Copy';
+                        button.classList.remove('copied');
+                    }, 2000);
+                } catch (err) {
+                    console.error('Failed to copy code:', err);
+                    button.textContent = 'Failed';
+                    setTimeout(() => {
+                        button.textContent = 'Copy';
+                    }, 2000);
+                }
+            });
+            
+            const wrapper = document.createElement('div');
+            wrapper.className = 'code-block-wrapper';
+            block.parentNode.insertBefore(wrapper, block);
+            wrapper.appendChild(block.parentNode);
+            wrapper.appendChild(button);
+        });
+    }
+
+    // Initialize code copy when DOM is ready
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', initializeCodeCopy);
+    } else {
+        initializeCodeCopy();
+    }
+
+    // Lazy loading for images
+    function initializeLazyLoading() {
+        const images = document.querySelectorAll('img[data-src]');
+        
+        if ('IntersectionObserver' in window) {
+            const imageObserver = new IntersectionObserver((entries) => {
+                entries.forEach(entry => {
+                    if (entry.isIntersecting) {
+                        const img = entry.target;
+                        img.src = img.dataset.src;
+                        img.removeAttribute('data-src');
+                        img.classList.remove('lazy');
+                        imageObserver.unobserve(img);
+                    }
+                });
+            });
+            
+            images.forEach(img => imageObserver.observe(img));
+        } else {
+            // Fallback for browsers without IntersectionObserver
+            images.forEach(img => {
+                img.src = img.dataset.src;
+                img.removeAttribute('data-src');
+            });
+        }
+    }
+
+    // Theme preference handling
+    function initializeThemeToggle() {
+        const themeToggle = document.getElementById('theme-toggle');
+        if (!themeToggle) return;
+
+        const preferredTheme = localStorage.getItem('preferred-theme') || 'eink';
+        document.body.className = `${preferredTheme}-theme`;
+
+        themeToggle.addEventListener('click', () => {
+            const currentTheme = document.body.className.includes('dark') ? 'dark' : 'eink';
+            const newTheme = currentTheme === 'eink' ? 'dark' : 'eink';
+            
+            document.body.className = `${newTheme}-theme`;
+            localStorage.setItem('preferred-theme', newTheme);
+            
+            themeToggle.setAttribute('aria-label', 
+                newTheme === 'eink' ? 'Switch to dark theme' : 'Switch to e-ink theme'
+            );
+        });
+    }
+
+    // Analytics and performance monitoring
+    function initializeAnalytics() {
+        // Track page views
+        if (typeof gtag !== 'undefined') {
+            gtag('config', 'GA_MEASUREMENT_ID', {
+                page_title: document.title,
+                page_location: window.location.href
+            });
+        }
+
+        // Track search usage
+        const searchInput = document.getElementById('search-input');
+        if (searchInput) {
+            let searchStartTime;
+            
+            searchInput.addEventListener('focus', () => {
+                searchStartTime = Date.now();
+            });
+            
+            searchInput.addEventListener('blur', () => {
+                if (searchStartTime) {
+                    const searchDuration = Date.now() - searchStartTime;
+                    // Track search engagement time
+                    if (typeof gtag !== 'undefined') {
+                        gtag('event', 'search_engagement', {
+                            event_category: 'Search',
+                            event_label: 'Duration',
+                            value: Math.round(searchDuration / 1000)
+                        });
+                    }
+                }
+            });
+        }
+
+        // Track bookmark usage
+        const bookmarkToggle = document.getElementById('bookmark-toggle');
+        if (bookmarkToggle) {
+            bookmarkToggle.addEventListener('click', () => {
+                const isBookmarked = bookmarkToggle.classList.contains('bookmarked');
+                if (typeof gtag !== 'undefined') {
+                    gtag('event', isBookmarked ? 'bookmark_remove' : 'bookmark_add', {
+                        event_category: 'Engagement',
+                        event_label: window.location.pathname
+                    });
+                }
+            });
+        }
+    }
+
+    // Initialize additional features
+    document.addEventListener('DOMContentLoaded', () => {
+        initializeLazyLoading();
+        initializeThemeToggle();
+        initializeAnalytics();
+    });
+
+    // Service Worker registration for offline functionality
+    if ('serviceWorker' in navigator) {
+        window.addEventListener('load', () => {
+            navigator.serviceWorker.register('/sw.js')
+                .then(registration => {
+                    console.log('SW registered: ', registration);
+                })
+                .catch(registrationError => {
+                    console.log('SW registration failed: ', registrationError);
+                });
+        });
+    }
+
+    // Export for global access
+    window.SolanaMCPDocs = {
+        search: performSearch,
+        toggleBookmark: (url, title) => toggleBookmark(url, title),
+        getBookmarks: () => JSON.parse(localStorage.getItem('solana-mcp-bookmarks') || '[]'),
+        clearBookmarks: () => {
+            localStorage.removeItem('solana-mcp-bookmarks');
+            window.bookmarks = [];
+        }
+    };
+
+})();
\ No newline at end of file
diff --git a/bookmarks.md b/bookmarks.md
new file mode 100644
index 0000000..cc4e7ad
--- /dev/null
+++ b/bookmarks.md
@@ -0,0 +1,341 @@
+---
+layout: default
+title: "Bookmarks"
+description: "Your bookmarked documentation pages"
+---
+
+<div class="bookmarks-page">
+  <header class="page-header">
+    <h1 class="page-title">📖 Your Bookmarks</h1>
+    <p class="page-description">
+      Quick access to your saved documentation pages.
+    </p>
+  </header>
+
+  <div class="bookmarks-actions">
+    <button id="clear-all-bookmarks" class="btn" style="background-color: var(--eink-white); border: 1px solid var(--eink-medium-gray);">
+      Clear All Bookmarks
+    </button>
+    <button id="export-bookmarks" class="btn" style="background-color: var(--eink-white); border: 1px solid var(--eink-medium-gray);">
+      Export Bookmarks
+    </button>
+  </div>
+
+  <div id="bookmarks-container" class="bookmarks-container">
+    <!-- Bookmarks will be populated here -->
+  </div>
+
+  <div id="empty-state" class="empty-state" style="display: none;">
+    <div class="empty-icon">📚</div>
+    <h3>No bookmarks yet</h3>
+    <p>Start exploring the documentation and bookmark pages you want to reference later.</p>
+    <a href="{{ '/' | relative_url }}" class="btn btn-primary">Browse Documentation</a>
+  </div>
+</div>
+
+<style>
+.bookmarks-page {
+  max-width: 800px;
+  margin: 0 auto;
+}
+
+.bookmarks-actions {
+  display: flex;
+  gap: 1rem;
+  margin: 2rem 0;
+  flex-wrap: wrap;
+}
+
+.bookmarks-actions .btn {
+  font-size: var(--font-size-sm);
+  padding: var(--spacing-sm) var(--spacing-md);
+}
+
+.bookmarks-container {
+  margin: 2rem 0;
+}
+
+.bookmark-item {
+  background-color: var(--eink-white);
+  border: 1px solid var(--eink-medium-gray);
+  border-radius: var(--border-radius-md);
+  padding: 1.5rem;
+  margin-bottom: 1rem;
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 1rem;
+  transition: all var(--transition-fast);
+}
+
+.bookmark-item:hover {
+  border-color: var(--accent-teal);
+  box-shadow: var(--shadow-sm);
+}
+
+.bookmark-content {
+  flex: 1;
+  min-width: 0;
+}
+
+.bookmark-title {
+  font-size: var(--font-size-lg);
+  font-weight: var(--font-weight-semibold);
+  color: var(--eink-black);
+  margin-bottom: 0.5rem;
+  text-decoration: none;
+  display: block;
+}
+
+.bookmark-title:hover {
+  color: var(--accent-teal);
+}
+
+.bookmark-url {
+  font-size: var(--font-size-sm);
+  color: var(--accent-teal);
+  margin-bottom: 0.5rem;
+  font-family: var(--font-family-mono);
+}
+
+.bookmark-date {
+  font-size: var(--font-size-xs);
+  color: var(--eink-charcoal);
+}
+
+.bookmark-actions {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  flex-shrink: 0;
+}
+
+.bookmark-action {
+  background: none;
+  border: 1px solid var(--eink-medium-gray);
+  color: var(--eink-charcoal);
+  padding: 0.25rem 0.5rem;
+  border-radius: var(--border-radius-sm);
+  font-size: var(--font-size-xs);
+  cursor: pointer;
+  transition: all var(--transition-fast);
+  min-width: 60px;
+}
+
+.bookmark-action:hover {
+  background-color: var(--eink-light-gray);
+  color: var(--eink-black);
+}
+
+.bookmark-action.remove:hover {
+  background-color: #fee;
+  border-color: #fcc;
+  color: #c33;
+}
+
+.empty-state {
+  text-align: center;
+  padding: 4rem 2rem;
+  background-color: var(--eink-white);
+  border: 1px solid var(--eink-medium-gray);
+  border-radius: var(--border-radius-lg);
+}
+
+.empty-icon {
+  font-size: 4rem;
+  margin-bottom: 1rem;
+}
+
+.empty-state h3 {
+  font-size: var(--font-size-xl);
+  color: var(--eink-black);
+  margin-bottom: 1rem;
+}
+
+.empty-state p {
+  color: var(--eink-charcoal);
+  margin-bottom: 2rem;
+  max-width: 400px;
+  margin-left: auto;
+  margin-right: auto;
+}
+
+.bookmark-stats {
+  background-color: var(--eink-light-gray);
+  padding: 1rem;
+  border-radius: var(--border-radius-md);
+  margin-bottom: 2rem;
+  text-align: center;
+}
+
+.stats-item {
+  display: inline-block;
+  margin: 0 1rem;
+  font-size: var(--font-size-sm);
+  color: var(--eink-charcoal);
+}
+
+.stats-number {
+  font-weight: var(--font-weight-semibold);
+  color: var(--accent-teal);
+  font-size: var(--font-size-lg);
+}
+
+@media (max-width: 768px) {
+  .bookmarks-page {
+    margin: 0;
+  }
+  
+  .bookmark-item {
+    flex-direction: column;
+    align-items: stretch;
+  }
+  
+  .bookmark-actions {
+    flex-direction: row;
+    justify-content: flex-end;
+  }
+  
+  .bookmarks-actions {
+    justify-content: center;
+  }
+}
+</style>
+
+<script>
+document.addEventListener('DOMContentLoaded', function() {
+  const bookmarksContainer = document.getElementById('bookmarks-container');
+  const emptyState = document.getElementById('empty-state');
+  const clearAllBtn = document.getElementById('clear-all-bookmarks');
+  const exportBtn = document.getElementById('export-bookmarks');
+  
+  function loadBookmarks() {
+    const bookmarks = JSON.parse(localStorage.getItem('solana-mcp-bookmarks') || '[]');
+    
+    if (bookmarks.length === 0) {
+      bookmarksContainer.style.display = 'none';
+      emptyState.style.display = 'block';
+      clearAllBtn.style.display = 'none';
+      exportBtn.style.display = 'none';
+      return;
+    }
+    
+    bookmarksContainer.style.display = 'block';
+    emptyState.style.display = 'none';
+    clearAllBtn.style.display = 'inline-block';
+    exportBtn.style.display = 'inline-block';
+    
+    // Sort bookmarks by date (newest first)
+    bookmarks.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
+    
+    // Add stats
+    const statsHtml = `
+      <div class="bookmark-stats">
+        <div class="stats-item">
+          <div class="stats-number">${bookmarks.length}</div>
+          <div>Bookmarked Pages</div>
+        </div>
+        <div class="stats-item">
+          <div class="stats-number">${getUniqueCategories(bookmarks).length}</div>
+          <div>Categories</div>
+        </div>
+      </div>
+    `;
+    
+    const bookmarksHtml = bookmarks.map((bookmark, index) => {
+      const date = bookmark.timestamp ? new Date(bookmark.timestamp).toLocaleDateString() : 'Unknown';
+      
+      return `
+        <div class="bookmark-item" data-index="${index}">
+          <div class="bookmark-content">
+            <a href="${bookmark.url}" class="bookmark-title">${bookmark.title}</a>
+            <div class="bookmark-url">${bookmark.url}</div>
+            <div class="bookmark-date">Bookmarked on ${date}</div>
+          </div>
+          <div class="bookmark-actions">
+            <button class="bookmark-action visit" onclick="window.location.href='${bookmark.url}'">Visit</button>
+            <button class="bookmark-action remove" onclick="removeBookmark(${index})">Remove</button>
+          </div>
+        </div>
+      `;
+    }).join('');
+    
+    bookmarksContainer.innerHTML = statsHtml + bookmarksHtml;
+  }
+  
+  function getUniqueCategories(bookmarks) {
+    const categories = new Set();
+    bookmarks.forEach(bookmark => {
+      if (bookmark.url.includes('/docs/')) {
+        const parts = bookmark.url.split('/');
+        const docType = parts[parts.length - 2] || 'general';
+        categories.add(docType);
+      }
+    });
+    return Array.from(categories);
+  }
+  
+  window.removeBookmark = function(index) {
+    if (confirm('Are you sure you want to remove this bookmark?')) {
+      let bookmarks = JSON.parse(localStorage.getItem('solana-mcp-bookmarks') || '[]');
+      bookmarks.splice(index, 1);
+      localStorage.setItem('solana-mcp-bookmarks', JSON.stringify(bookmarks));
+      window.bookmarks = bookmarks;
+      loadBookmarks();
+      
+      // Update bookmark icon on current page if it matches
+      const currentUrl = window.location.pathname;
+      const bookmarkToggle = document.getElementById('bookmark-toggle');
+      if (bookmarkToggle && !bookmarks.some(b => b.url === currentUrl)) {
+        bookmarkToggle.classList.remove('bookmarked');
+        bookmarkToggle.setAttribute('aria-label', 'Bookmark this page');
+      }
+    }
+  };
+  
+  clearAllBtn.addEventListener('click', function() {
+    if (confirm('Are you sure you want to clear all bookmarks? This action cannot be undone.')) {
+      localStorage.removeItem('solana-mcp-bookmarks');
+      window.bookmarks = [];
+      loadBookmarks();
+      
+      // Update bookmark icon on current page
+      const bookmarkToggle = document.getElementById('bookmark-toggle');
+      if (bookmarkToggle) {
+        bookmarkToggle.classList.remove('bookmarked');
+        bookmarkToggle.setAttribute('aria-label', 'Bookmark this page');
+      }
+    }
+  });
+  
+  exportBtn.addEventListener('click', function() {
+    const bookmarks = JSON.parse(localStorage.getItem('solana-mcp-bookmarks') || '[]');
+    
+    const exportData = {
+      title: 'Solana MCP Server Documentation Bookmarks',
+      exported: new Date().toISOString(),
+      bookmarks: bookmarks
+    };
+    
+    const dataStr = JSON.stringify(exportData, null, 2);
+    const dataBlob = new Blob([dataStr], { type: 'application/json' });
+    
+    const link = document.createElement('a');
+    link.href = URL.createObjectURL(dataBlob);
+    link.download = `solana-mcp-bookmarks-${new Date().toISOString().split('T')[0]}.json`;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+  });
+  
+  // Initial load
+  loadBookmarks();
+  
+  // Listen for storage changes from other tabs
+  window.addEventListener('storage', function(e) {
+    if (e.key === 'solana-mcp-bookmarks') {
+      loadBookmarks();
+    }
+  });
+});
+</script>
\ No newline at end of file
diff --git a/index.md b/index.md
new file mode 100644
index 0000000..50ef2c0
--- /dev/null
+++ b/index.md
@@ -0,0 +1,258 @@
+---
+layout: home
+title: "Solana MCP Server Documentation"
+description: "A comprehensive Model Context Protocol server for seamless Solana blockchain integration with AI assistants like Claude"
+---
+
+<div class="hero-section">
+  <h1 class="hero-title">Solana MCP Server</h1>
+  <p class="hero-subtitle">
+    A comprehensive Model Context Protocol server that provides seamless access to Solana blockchain data through AI assistants like Claude. Query blockchain information with natural language.
+  </p>
+  <div class="hero-actions">
+    <a href="{{ '/docs/ONBOARDING/' | relative_url }}" class="btn btn-primary">Get Started</a>
+    <a href="{{ '/docs/API_REFERENCE/' | relative_url }}" class="btn">API Reference</a>
+    <a href="{{ site.github.repository_url }}" class="btn" target="_blank" rel="noopener noreferrer">GitHub</a>
+  </div>
+</div>
+
+<div class="features-grid">
+  <div class="feature-card">
+    <span class="feature-icon">🚀</span>
+    <h3 class="feature-title">Comprehensive RPC Coverage</h3>
+    <p class="feature-description">
+      47 Solana RPC methods across all major categories including accounts, blocks, transactions, tokens, and system operations. Real-time blockchain data with configurable commitment levels.
+    </p>
+  </div>
+  
+  <div class="feature-card">
+    <span class="feature-icon">🌐</span>
+    <h3 class="feature-title">Multi-Network Support</h3>
+    <p class="feature-description">
+      Query multiple SVM-compatible networks simultaneously. Dynamic network configuration and management with parallel execution and result aggregation.
+    </p>
+  </div>
+  
+  <div class="feature-card">
+    <span class="feature-icon">🛠️</span>
+    <h3 class="feature-title">Flexible Deployment</h3>
+    <p class="feature-description">
+      Deploy locally with Claude Desktop, as HTTP endpoints, serverless functions (AWS Lambda, Vercel, Google Cloud), or container orchestration (Docker, Kubernetes).
+    </p>
+  </div>
+  
+  <div class="feature-card">
+    <span class="feature-icon">⚡</span>
+    <h3 class="feature-title">High Performance</h3>
+    <p class="feature-description">
+      Connection pooling, persistent RPC clients, configurable caching layers, parallel multi-network queries, and built-in rate limiting with error recovery.
+    </p>
+  </div>
+  
+  <div class="feature-card">
+    <span class="feature-icon">📊</span>
+    <h3 class="feature-title">Monitoring & Scaling</h3>
+    <p class="feature-description">
+      Prometheus metrics, Kubernetes HPA support, health checks, and comprehensive logging for production-ready deployments with autoscaling capabilities.
+    </p>
+  </div>
+  
+  <div class="feature-card">
+    <span class="feature-icon">🔒</span>
+    <h3 class="feature-title">Security First</h3>
+    <p class="feature-description">
+      Regular security audits with cargo audit, dependency updates, vulnerability monitoring, and comprehensive security documentation.
+    </p>
+  </div>
+</div>
+
+<section class="docs-section">
+  <h2 style="text-align: center; margin-bottom: 2rem; font-size: 2.25rem; color: var(--eink-black);">📚 Documentation</h2>
+  
+  <div class="docs-grid">
+    <a href="{{ '/docs/ONBOARDING/' | relative_url }}" class="docs-card">
+      <span class="docs-card-icon">🚀</span>
+      <h3 class="docs-card-title">Quick Start</h3>
+      <p class="docs-card-description">
+        Get up and running quickly with step-by-step setup instructions, configuration, and your first queries.
+      </p>
+    </a>
+    
+    <a href="{{ '/docs/ARCHITECTURE/' | relative_url }}" class="docs-card">
+      <span class="docs-card-icon">🏗️</span>
+      <h3 class="docs-card-title">Architecture</h3>
+      <p class="docs-card-description">
+        Understand the system design, component interactions, and internal workings of the MCP server.
+      </p>
+    </a>
+    
+    <a href="{{ '/docs/API_REFERENCE/' | relative_url }}" class="docs-card">
+      <span class="docs-card-icon">📖</span>
+      <h3 class="docs-card-title">API Reference</h3>
+      <p class="docs-card-description">
+        Complete documentation of all 47 RPC methods with parameters, examples, and response formats.
+      </p>
+    </a>
+    
+    <a href="{{ '/docs/DEPLOYMENT/' | relative_url }}" class="docs-card">
+      <span class="docs-card-icon">🚀</span>
+      <h3 class="docs-card-title">Deployment</h3>
+      <p class="docs-card-description">
+        Deploy locally, to cloud platforms, serverless functions, or container orchestration systems.
+      </p>
+    </a>
+    
+    <a href="{{ '/docs/CONFIGURATION/' | relative_url }}" class="docs-card">
+      <span class="docs-card-icon">⚙️</span>
+      <h3 class="docs-card-title">Configuration</h3>
+      <p class="docs-card-description">
+        Comprehensive guide to configuration options, environment variables, and customization.
+      </p>
+    </a>
+    
+    <a href="{{ '/docs/EXAMPLES/' | relative_url }}" class="docs-card">
+      <span class="docs-card-icon">💡</span>
+      <h3 class="docs-card-title">Examples</h3>
+      <p class="docs-card-description">
+        Real-world examples, use cases, and practical applications with sample queries and responses.
+      </p>
+    </a>
+    
+    <a href="{{ '/docs/web-service/' | relative_url }}" class="docs-card">
+      <span class="docs-card-icon">🌐</span>
+      <h3 class="docs-card-title">Web Service</h3>
+      <p class="docs-card-description">
+        HTTP API mode with JSON-RPC endpoints, health checks, and Prometheus metrics integration.
+      </p>
+    </a>
+    
+    <a href="{{ '/docs/metrics/' | relative_url }}" class="docs-card">
+      <span class="docs-card-icon">📊</span>
+      <h3 class="docs-card-title">Metrics & Monitoring</h3>
+      <p class="docs-card-description">
+        Prometheus metrics, Kubernetes autoscaling, performance monitoring, and observability setup.
+      </p>
+    </a>
+    
+    <a href="{{ '/docs/security-audit/' | relative_url }}" class="docs-card">
+      <span class="docs-card-icon">🔒</span>
+      <h3 class="docs-card-title">Security</h3>
+      <p class="docs-card-description">
+        Security audit reports, vulnerability assessments, best practices, and compliance information.
+      </p>
+    </a>
+  </div>
+</section>
+
+<section style="margin: 4rem 0; padding: 3rem; background-color: var(--eink-white); border: 1px solid var(--eink-medium-gray); border-radius: 12px;">
+  <h2 style="text-align: center; margin-bottom: 2rem; font-size: 2rem; color: var(--eink-black);">🎯 Usage Examples</h2>
+  
+  <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 2rem;">
+    <div>
+      <h3 style="color: var(--accent-teal); margin-bottom: 1rem;">💰 Basic Queries</h3>
+      <ul style="list-style-type: none; padding: 0;">
+        <li style="margin-bottom: 0.5rem; padding: 0.5rem; background: var(--eink-light-gray); border-radius: 6px;">
+          "What's the SOL balance of address Gh9ZwEmdLJ8DscKNTkTqPbNwLNNBjuSzaG9Vp2KGtKJr?"
+        </li>
+        <li style="margin-bottom: 0.5rem; padding: 0.5rem; background: var(--eink-light-gray); border-radius: 6px;">
+          "Show me the current slot number"
+        </li>
+        <li style="margin-bottom: 0.5rem; padding: 0.5rem; background: var(--eink-light-gray); border-radius: 6px;">
+          "Get information about the latest block"
+        </li>
+      </ul>
+    </div>
+    
+    <div>
+      <h3 style="color: var(--accent-teal); margin-bottom: 1rem;">🌐 Multi-Network</h3>
+      <ul style="list-style-type: none; padding: 0;">
+        <li style="margin-bottom: 0.5rem; padding: 0.5rem; background: var(--eink-light-gray); border-radius: 6px;">
+          "List all available SVM networks"
+        </li>
+        <li style="margin-bottom: 0.5rem; padding: 0.5rem; background: var(--eink-light-gray); border-radius: 6px;">
+          "Enable Eclipse mainnet for queries"
+        </li>
+        <li style="margin-bottom: 0.5rem; padding: 0.5rem; background: var(--eink-light-gray); border-radius: 6px;">
+          "Check SOL balance on all enabled networks"
+        </li>
+      </ul>
+    </div>
+    
+    <div>
+      <h3 style="color: var(--accent-teal); margin-bottom: 1rem;">🔧 Advanced Operations</h3>
+      <ul style="list-style-type: none; padding: 0;">
+        <li style="margin-bottom: 0.5rem; padding: 0.5rem; background: var(--eink-light-gray); border-radius: 6px;">
+          "Show me the largest USDC token accounts"
+        </li>
+        <li style="margin-bottom: 0.5rem; padding: 0.5rem; background: var(--eink-light-gray); border-radius: 6px;">
+          "Get the leader schedule for the current epoch"
+        </li>
+        <li style="margin-bottom: 0.5rem; padding: 0.5rem; background: var(--eink-light-gray); border-radius: 6px;">
+          "Check block production stats for a validator"
+        </li>
+      </ul>
+    </div>
+  </div>
+</section>
+
+<section style="text-align: center; margin: 4rem 0;">
+  <h2 style="margin-bottom: 1.5rem; font-size: 2rem; color: var(--eink-black);">🔗 Links & Resources</h2>
+  <div style="display: flex; justify-content: center; gap: 2rem; flex-wrap: wrap;">
+    <a href="{{ site.github.repository_url }}" target="_blank" rel="noopener noreferrer" 
+       style="color: var(--accent-teal); text-decoration: none; font-weight: 600;">
+      GitHub Repository
+    </a>
+    <a href="{{ site.github.repository_url }}/releases" target="_blank" rel="noopener noreferrer"
+       style="color: var(--accent-teal); text-decoration: none; font-weight: 600;">
+      Releases
+    </a>
+    <a href="{{ site.github.repository_url }}/issues" target="_blank" rel="noopener noreferrer"
+       style="color: var(--accent-teal); text-decoration: none; font-weight: 600;">
+      Report Issues
+    </a>
+    <a href="{{ '/search/' | relative_url }}"
+       style="color: var(--accent-teal); text-decoration: none; font-weight: 600;">
+      Search Documentation
+    </a>
+  </div>
+</section>
+
+<script>
+// Add some interactive enhancements
+document.addEventListener('DOMContentLoaded', function() {
+    // Animate feature cards on scroll
+    const featureCards = document.querySelectorAll('.feature-card, .docs-card');
+    
+    const observer = new IntersectionObserver((entries) => {
+        entries.forEach(entry => {
+            if (entry.isIntersecting) {
+                entry.target.style.opacity = '1';
+                entry.target.style.transform = 'translateY(0)';
+            }
+        });
+    }, { 
+        threshold: 0.1,
+        rootMargin: '0px 0px -50px 0px'
+    });
+    
+    featureCards.forEach(card => {
+        card.style.opacity = '0';
+        card.style.transform = 'translateY(20px)';
+        card.style.transition = 'opacity 0.6s ease, transform 0.6s ease';
+        observer.observe(card);
+    });
+    
+    // Add hover effects to cards
+    featureCards.forEach(card => {
+        card.addEventListener('mouseenter', function() {
+            this.style.transform = 'translateY(-5px)';
+            this.style.boxShadow = '0 10px 25px rgba(0, 0, 0, 0.1)';
+        });
+        
+        card.addEventListener('mouseleave', function() {
+            this.style.transform = 'translateY(0)';
+            this.style.boxShadow = '';
+        });
+    });
+});
+</script>
\ No newline at end of file
diff --git a/search.md b/search.md
new file mode 100644
index 0000000..185accd
--- /dev/null
+++ b/search.md
@@ -0,0 +1,361 @@
+---
+layout: default
+title: "Search Documentation"
+description: "Search through all Solana MCP Server documentation"
+---
+
+<div class="search-page">
+  <header class="page-header">
+    <h1 class="page-title">Search Documentation</h1>
+    <p class="page-description">
+      Find information quickly across all documentation pages.
+    </p>
+  </header>
+
+  <div class="search-form">
+    <div class="search-input-wrapper">
+      <input type="text" id="page-search-input" placeholder="Enter search terms..." 
+             autocomplete="off" class="search-input-large">
+      <button type="button" id="clear-search" class="search-clear" aria-label="Clear search">×</button>
+    </div>
+    <p class="search-help">
+      <strong>Tips:</strong> Try searching for specific RPC methods, configuration options, or deployment platforms.
+    </p>
+  </div>
+
+  <div class="search-results-container">
+    <div id="page-search-results" class="search-results-list"></div>
+    <div id="search-status" class="search-status">
+      Enter search terms above to find relevant documentation.
+    </div>
+  </div>
+
+  <div class="search-suggestions">
+    <h3>Popular Searches</h3>
+    <div class="suggestion-tags">
+      <button class="suggestion-tag" data-query="getAccountInfo">getAccountInfo</button>
+      <button class="suggestion-tag" data-query="deployment">Deployment</button>
+      <button class="suggestion-tag" data-query="configuration">Configuration</button>
+      <button class="suggestion-tag" data-query="docker">Docker</button>
+      <button class="suggestion-tag" data-query="kubernetes">Kubernetes</button>
+      <button class="suggestion-tag" data-query="tokens">Token Methods</button>
+      <button class="suggestion-tag" data-query="metrics">Metrics</button>
+      <button class="suggestion-tag" data-query="security">Security</button>
+    </div>
+  </div>
+</div>
+
+<style>
+.search-page {
+  max-width: 800px;
+  margin: 0 auto;
+}
+
+.search-form {
+  margin: 2rem 0;
+}
+
+.search-input-wrapper {
+  position: relative;
+  margin-bottom: 1rem;
+}
+
+.search-input-large {
+  width: 100%;
+  padding: 1rem 3rem 1rem 1rem;
+  font-size: 1.125rem;
+  border: 2px solid var(--eink-medium-gray);
+  border-radius: var(--border-radius-md);
+  background-color: var(--eink-white);
+  color: var(--eink-black);
+  font-family: inherit;
+  transition: border-color var(--transition-fast);
+}
+
+.search-input-large:focus {
+  outline: none;
+  border-color: var(--accent-teal);
+  box-shadow: 0 0 0 3px rgba(45, 95, 95, 0.1);
+}
+
+.search-clear {
+  position: absolute;
+  right: 1rem;
+  top: 50%;
+  transform: translateY(-50%);
+  background: none;
+  border: none;
+  font-size: 1.5rem;
+  color: var(--eink-charcoal);
+  cursor: pointer;
+  width: 24px;
+  height: 24px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: var(--border-radius-sm);
+  transition: all var(--transition-fast);
+}
+
+.search-clear:hover {
+  background-color: var(--eink-light-gray);
+  color: var(--eink-black);
+}
+
+.search-help {
+  font-size: var(--font-size-sm);
+  color: var(--eink-charcoal);
+  margin: 0;
+}
+
+.search-results-container {
+  margin: 2rem 0;
+}
+
+.search-results-list {
+  margin-bottom: 2rem;
+}
+
+.search-status {
+  text-align: center;
+  color: var(--eink-charcoal);
+  font-style: italic;
+  padding: 2rem;
+  background-color: var(--eink-light-gray);
+  border-radius: var(--border-radius-md);
+}
+
+.search-suggestions h3 {
+  margin-bottom: 1rem;
+  color: var(--eink-black);
+}
+
+.suggestion-tags {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+}
+
+.suggestion-tag {
+  background-color: var(--eink-white);
+  border: 1px solid var(--eink-medium-gray);
+  color: var(--eink-charcoal);
+  padding: 0.5rem 1rem;
+  border-radius: var(--border-radius-sm);
+  cursor: pointer;
+  font-size: var(--font-size-sm);
+  transition: all var(--transition-fast);
+}
+
+.suggestion-tag:hover {
+  background-color: var(--accent-teal);
+  color: var(--eink-white);
+  border-color: var(--accent-teal);
+}
+
+.search-result-item {
+  background-color: var(--eink-white);
+  border: 1px solid var(--eink-medium-gray);
+  border-radius: var(--border-radius-md);
+  padding: 1.5rem;
+  margin-bottom: 1rem;
+  cursor: pointer;
+  transition: all var(--transition-fast);
+}
+
+.search-result-item:hover {
+  border-color: var(--accent-teal);
+  box-shadow: var(--shadow-sm);
+}
+
+.search-result-title {
+  font-size: var(--font-size-lg);
+  font-weight: var(--font-weight-semibold);
+  color: var(--eink-black);
+  margin-bottom: 0.5rem;
+}
+
+.search-result-url {
+  font-size: var(--font-size-xs);
+  color: var(--accent-teal);
+  margin-bottom: 0.5rem;
+}
+
+.search-result-snippet {
+  color: var(--eink-charcoal);
+  line-height: var(--line-height-relaxed);
+}
+
+.search-result-snippet mark {
+  background-color: var(--accent-amber);
+  color: var(--eink-black);
+  padding: 0.1em 0.2em;
+  border-radius: 2px;
+}
+
+@media (max-width: 768px) {
+  .search-page {
+    margin: 0;
+  }
+  
+  .suggestion-tags {
+    justify-content: center;
+  }
+}
+</style>
+
+<script>
+document.addEventListener('DOMContentLoaded', function() {
+  const searchInput = document.getElementById('page-search-input');
+  const clearButton = document.getElementById('clear-search');
+  const resultsContainer = document.getElementById('page-search-results');
+  const statusElement = document.getElementById('search-status');
+  const suggestionTags = document.querySelectorAll('.suggestion-tag');
+  
+  let searchIndex;
+  let searchData = [];
+  
+  // Initialize search
+  if (window.searchData) {
+    searchData = window.searchData;
+    searchIndex = lunr(function() {
+      this.ref('id');
+      this.field('title', { boost: 10 });
+      this.field('content');
+      
+      searchData.forEach((doc) => {
+        this.add(doc);
+      });
+    });
+  }
+  
+  // Search input handler
+  let searchTimeout;
+  searchInput.addEventListener('input', function() {
+    clearTimeout(searchTimeout);
+    const query = this.value.trim();
+    
+    if (query.length === 0) {
+      resultsContainer.innerHTML = '';
+      statusElement.textContent = 'Enter search terms above to find relevant documentation.';
+      statusElement.style.display = 'block';
+      return;
+    }
+    
+    if (query.length < 2) {
+      statusElement.textContent = 'Enter at least 2 characters to search.';
+      statusElement.style.display = 'block';
+      resultsContainer.innerHTML = '';
+      return;
+    }
+    
+    statusElement.textContent = 'Searching...';
+    statusElement.style.display = 'block';
+    
+    searchTimeout = setTimeout(() => {
+      performSearch(query);
+    }, 200);
+  });
+  
+  // Clear button
+  clearButton.addEventListener('click', function() {
+    searchInput.value = '';
+    resultsContainer.innerHTML = '';
+    statusElement.textContent = 'Enter search terms above to find relevant documentation.';
+    statusElement.style.display = 'block';
+    searchInput.focus();
+  });
+  
+  // Suggestion tags
+  suggestionTags.forEach(tag => {
+    tag.addEventListener('click', function() {
+      const query = this.getAttribute('data-query');
+      searchInput.value = query;
+      performSearch(query);
+    });
+  });
+  
+  function performSearch(query) {
+    if (!searchIndex) {
+      statusElement.textContent = 'Search not available.';
+      return;
+    }
+    
+    try {
+      const results = searchIndex.search(query);
+      displayResults(results, query);
+    } catch (e) {
+      console.error('Search error:', e);
+      statusElement.textContent = 'Search error occurred.';
+    }
+  }
+  
+  function displayResults(results, query) {
+    if (results.length === 0) {
+      resultsContainer.innerHTML = '';
+      statusElement.textContent = `No results found for "${query}".`;
+      statusElement.style.display = 'block';
+      return;
+    }
+    
+    statusElement.style.display = 'none';
+    
+    const html = results.slice(0, 10).map(result => {
+      const doc = searchData.find(d => d.id === result.ref);
+      if (!doc) return '';
+      
+      const title = highlightMatch(doc.title, query);
+      const snippet = generateSnippet(doc.content, query);
+      
+      return `
+        <div class="search-result-item" onclick="window.location.href='${doc.url}'">
+          <div class="search-result-title">${title}</div>
+          <div class="search-result-url">${doc.url}</div>
+          <div class="search-result-snippet">${snippet}</div>
+        </div>
+      `;
+    }).join('');
+    
+    resultsContainer.innerHTML = html;
+  }
+  
+  function highlightMatch(text, query) {
+    const regex = new RegExp(`(${escapeRegex(query)})`, 'gi');
+    return text.replace(regex, '<mark>$1</mark>');
+  }
+  
+  function generateSnippet(content, query, length = 200) {
+    const words = content.toLowerCase().split(/\s+/);
+    const queryWords = query.toLowerCase().split(/\s+/);
+    
+    let bestIndex = 0;
+    let bestScore = 0;
+    
+    for (let i = 0; i < words.length - 20; i++) {
+      let score = 0;
+      for (let j = i; j < Math.min(i + 30, words.length); j++) {
+        if (queryWords.some(qw => words[j].includes(qw))) {
+          score += 1;
+        }
+      }
+      if (score > bestScore) {
+        bestScore = score;
+        bestIndex = i;
+      }
+    }
+    
+    const snippetWords = content.split(/\s+/).slice(bestIndex, bestIndex + 30);
+    let snippet = snippetWords.join(' ');
+    
+    if (snippet.length > length) {
+      snippet = snippet.substring(0, length) + '...';
+    }
+    
+    return highlightMatch(snippet, query);
+  }
+  
+  function escapeRegex(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+});
+</script>
\ No newline at end of file

From 42e5022a6093a990e6f76f997b48b4bbd26e24a3 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 28 Jul 2025 19:34:06 +0000
Subject: [PATCH 3/6] Add comprehensive micro-animations and fix documentation
 page rendering

Co-authored-by: 0xrinegade <101195284+0xrinegade@users.noreply.github.com>
---
 _docs/README.md                   |   8 +
 _docs/benchmarks.md               |   8 +
 _docs/developer/error_handling.md |   8 +
 _docs/docker-scaling.md           |   8 +
 _docs/mcp-json-rpc-api.md         |   8 +
 _docs/metrics.md                  |   8 +
 _docs/security-audit.md           |   8 +
 _docs/timeout-configuration.md    |   8 +
 _docs/web-service.md              |   8 +
 assets/css/main.css               | 306 ++++++++++++++++++++++++++-
 assets/js/main.js                 | 331 ++++++++++++++++++++++++++++++
 11 files changed, 698 insertions(+), 11 deletions(-)

diff --git a/_docs/README.md b/_docs/README.md
index 864f060..b69a8c3 100644
--- a/_docs/README.md
+++ b/_docs/README.md
@@ -1,3 +1,11 @@
+---
+layout: docs
+title: "Documentation Overview"
+description: "Table of contents and navigation guide for all documentation"
+order: 0
+category: getting_started
+---
+
 # Solana MCP Server Documentation
 
 ## Table of Contents
diff --git a/_docs/benchmarks.md b/_docs/benchmarks.md
index 6798f49..1baedb4 100644
--- a/_docs/benchmarks.md
+++ b/_docs/benchmarks.md
@@ -1,3 +1,11 @@
+---
+layout: docs
+title: "Benchmark Tests"
+description: "Comprehensive performance benchmarks and testing results"
+order: 20
+category: architecture
+---
+
 # Benchmark Tests
 
 This directory contains comprehensive performance benchmarks for the Solana MCP Server.
diff --git a/_docs/developer/error_handling.md b/_docs/developer/error_handling.md
index cf2ebb1..97ea89e 100644
--- a/_docs/developer/error_handling.md
+++ b/_docs/developer/error_handling.md
@@ -1,3 +1,11 @@
+---
+layout: docs
+title: "Error Handling and Logging Guidelines"
+description: "Robust error handling and logging patterns for development and production"
+order: 101
+category: developer
+---
+
 # Error Handling and Logging Guidelines
 
 ## Overview
diff --git a/_docs/docker-scaling.md b/_docs/docker-scaling.md
index 90db059..0a14db6 100644
--- a/_docs/docker-scaling.md
+++ b/_docs/docker-scaling.md
@@ -1,3 +1,11 @@
+---
+layout: docs
+title: "Docker Scaling Guide"
+description: "Scaling strategies for Docker environments with autoscaling and orchestration"
+order: 12
+category: deployment
+---
+
 # Docker Scaling Guide
 
 This guide covers scaling strategies for the Solana MCP Server in Docker environments.
diff --git a/_docs/mcp-json-rpc-api.md b/_docs/mcp-json-rpc-api.md
index 52a25f5..42bd253 100644
--- a/_docs/mcp-json-rpc-api.md
+++ b/_docs/mcp-json-rpc-api.md
@@ -1,3 +1,11 @@
+---
+layout: docs
+title: "MCP JSON-RPC API Specification"
+description: "Model Context Protocol JSON-RPC API implementation details and compliance"
+order: 31
+category: api
+---
+
 # MCP JSON-RPC API Specification
 
 This document describes the Model Context Protocol (MCP) JSON-RPC API implementation for the Solana MCP Server.
diff --git a/_docs/metrics.md b/_docs/metrics.md
index 7919459..120e0c4 100644
--- a/_docs/metrics.md
+++ b/_docs/metrics.md
@@ -1,3 +1,11 @@
+---
+layout: docs
+title: "Metrics & Monitoring"
+description: "Prometheus metrics, Kubernetes autoscaling, and observability setup"
+order: 13
+category: deployment
+---
+
 # Metrics Documentation
 
 The Solana MCP Server exposes comprehensive metrics for monitoring, alerting, and autoscaling. This document describes the available metrics and how to use them.
diff --git a/_docs/security-audit.md b/_docs/security-audit.md
index af83454..254c6ea 100644
--- a/_docs/security-audit.md
+++ b/_docs/security-audit.md
@@ -1,3 +1,11 @@
+---
+layout: docs
+title: "Security Audit"
+description: "Security audit reports, vulnerability assessments, and compliance information"
+order: 14
+category: deployment
+---
+
 # Security Audit Documentation
 
 ## Overview
diff --git a/_docs/timeout-configuration.md b/_docs/timeout-configuration.md
index 0d6a3a1..a130b59 100644
--- a/_docs/timeout-configuration.md
+++ b/_docs/timeout-configuration.md
@@ -1,3 +1,11 @@
+---
+layout: docs
+title: "Timeout Configuration"
+description: "Comprehensive timeout configurations for reliable performance"
+order: 15
+category: configuration
+---
+
 # Timeout Configuration
 
 The Solana MCP Server provides comprehensive timeout configurations to prevent hanging operations and ensure reliable performance in production environments.
diff --git a/_docs/web-service.md b/_docs/web-service.md
index 5bbed76..3e48e98 100644
--- a/_docs/web-service.md
+++ b/_docs/web-service.md
@@ -1,3 +1,11 @@
+---
+layout: docs
+title: "Web Service Mode"
+description: "HTTP API mode with JSON-RPC endpoints, health checks, and metrics integration"
+order: 11
+category: deployment
+---
+
 # Solana MCP Server - Web Service Mode
 
 The Solana MCP Server supports running as an HTTP web service, providing full MCP JSON-RPC 2.0 API compliance for web-based integrations.
diff --git a/assets/css/main.css b/assets/css/main.css
index 1e458d4..21b5f1d 100644
--- a/assets/css/main.css
+++ b/assets/css/main.css
@@ -187,11 +187,33 @@ body {
   border-radius: var(--border-radius-sm);
   transition: all var(--transition-fast);
   position: relative;
+  overflow: hidden;
+}
+
+.nav-link::before {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: -100%;
+  width: 100%;
+  height: 100%;
+  background: linear-gradient(90deg, transparent, rgba(45, 95, 95, 0.1), transparent);
+  transition: left 0.4s ease;
 }
 
 .nav-link:hover {
   color: var(--eink-black);
   background-color: var(--eink-light-gray);
+  transform: translateY(-1px);
+}
+
+.nav-link:hover::before {
+  left: 100%;
+}
+
+.nav-link:active {
+  transform: translateY(0);
+  transition: all 0.1s ease;
 }
 
 .nav-link.active {
@@ -209,6 +231,7 @@ body {
   height: 2px;
   background-color: var(--accent-teal);
   border-radius: 1px;
+  animation: scaleIn 0.3s ease;
 }
 
 /* Header utilities */
@@ -231,6 +254,25 @@ body {
   display: flex;
   align-items: center;
   justify-content: center;
+  position: relative;
+  transform: scale(1);
+  overflow: hidden;
+}
+
+.search-toggle::before,
+.bookmark-toggle::before,
+.menu-toggle::before {
+  content: '';
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  width: 0;
+  height: 0;
+  background-color: var(--eink-light-gray);
+  border-radius: 50%;
+  transform: translate(-50%, -50%);
+  transition: all 0.3s ease;
+  z-index: -1;
 }
 
 .search-toggle:hover,
@@ -238,14 +280,45 @@ body {
 .menu-toggle:hover {
   background-color: var(--eink-light-gray);
   color: var(--eink-black);
+  transform: scale(1.05);
+}
+
+.search-toggle:hover::before,
+.bookmark-toggle:hover::before,
+.menu-toggle:hover::before {
+  width: 40px;
+  height: 40px;
+}
+
+.search-toggle:active,
+.bookmark-toggle:active,
+.menu-toggle:active {
+  transform: scale(0.95);
+  transition: all 0.1s ease;
+}
+
+.search-toggle svg,
+.bookmark-toggle svg,
+.menu-toggle svg {
+  transition: all var(--transition-fast);
+}
+
+.search-toggle:hover svg {
+  transform: rotate(5deg);
+}
+
+.bookmark-toggle:hover svg {
+  transform: scale(1.1);
 }
 
 .bookmark-toggle.bookmarked {
   color: var(--accent-amber);
+  animation: bounce 0.5s ease;
 }
 
 .bookmark-toggle.bookmarked svg {
   fill: currentColor;
+  transform: scale(1.1);
 }
 
 /* Menu toggle (hamburger) */
@@ -261,19 +334,22 @@ body {
   height: 2px;
   background-color: currentColor;
   margin: 2px 0;
-  transition: all var(--transition-fast);
+  border-radius: 1px;
+  transition: all 0.3s cubic-bezier(0.68, -0.55, 0.265, 1.55);
+  transform-origin: center;
 }
 
 .menu-toggle[aria-expanded="true"] .menu-bar:nth-child(1) {
-  transform: rotate(45deg) translate(5px, 5px);
+  transform: rotate(45deg) translate(6px, 6px);
 }
 
 .menu-toggle[aria-expanded="true"] .menu-bar:nth-child(2) {
   opacity: 0;
+  transform: scale(0);
 }
 
 .menu-toggle[aria-expanded="true"] .menu-bar:nth-child(3) {
-  transform: rotate(-45deg) translate(7px, -6px);
+  transform: rotate(-45deg) translate(6px, -6px);
 }
 
 /* Search overlay */
@@ -288,7 +364,7 @@ body {
   z-index: 200;
   opacity: 0;
   visibility: hidden;
-  transition: all var(--transition-normal);
+  transition: all 0.3s cubic-bezier(0.16, 1, 0.3, 1);
 }
 
 .search-overlay.active {
@@ -300,13 +376,20 @@ body {
   position: absolute;
   top: 20%;
   left: 50%;
-  transform: translateX(-50%);
+  transform: translateX(-50%) translateY(20px);
   width: 90%;
   max-width: 600px;
   background-color: var(--eink-white);
   border-radius: var(--border-radius-lg);
   box-shadow: var(--shadow-lg);
   overflow: hidden;
+  transition: all 0.3s cubic-bezier(0.16, 1, 0.3, 1);
+  opacity: 0;
+}
+
+.search-overlay.active .search-container {
+  transform: translateX(-50%) translateY(0);
+  opacity: 1;
 }
 
 .search-input-wrapper {
@@ -362,11 +445,36 @@ body {
   padding: var(--spacing-md) var(--spacing-lg);
   border-bottom: var(--border-width) solid var(--eink-light-gray);
   cursor: pointer;
-  transition: background-color var(--transition-fast);
+  transition: all var(--transition-fast);
+  position: relative;
+  background-color: transparent;
+}
+
+.search-result::before {
+  content: '';
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 0;
+  height: 100%;
+  background-color: var(--eink-light-gray);
+  transition: width 0.3s ease;
+  z-index: -1;
 }
 
 .search-result:hover {
   background-color: var(--eink-light-gray);
+  transform: translateX(4px);
+}
+
+.search-result:hover::before {
+  width: 4px;
+  background-color: var(--accent-teal);
+}
+
+.search-result:active {
+  transform: translateX(2px);
+  background-color: var(--eink-medium-gray);
 }
 
 .search-result:last-child {
@@ -788,22 +896,56 @@ body {
   cursor: pointer;
   background-color: var(--eink-white);
   color: var(--eink-black);
+  position: relative;
+  overflow: hidden;
+  transform: translateY(0);
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
+}
+
+.btn::before {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: -100%;
+  width: 100%;
+  height: 100%;
+  background: linear-gradient(90deg, transparent, rgba(255, 255, 255, 0.4), transparent);
+  transition: left 0.5s ease;
 }
 
 .btn:hover {
   border-color: var(--accent-teal);
-  box-shadow: var(--shadow-sm);
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+  transform: translateY(-1px);
+}
+
+.btn:hover::before {
+  left: 100%;
+}
+
+.btn:active {
+  transform: translateY(0) scale(0.98);
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+  transition: all 0.1s ease;
 }
 
 .btn-primary {
   background-color: var(--accent-teal);
   color: var(--eink-white);
   border-color: var(--accent-teal);
+  box-shadow: 0 2px 8px rgba(45, 95, 95, 0.2);
 }
 
 .btn-primary:hover {
   background-color: var(--accent-teal-light);
   border-color: var(--accent-teal-light);
+  box-shadow: 0 4px 16px rgba(45, 95, 95, 0.3);
+  transform: translateY(-2px);
+}
+
+.btn-primary:active {
+  transform: translateY(0) scale(0.98);
+  box-shadow: 0 2px 8px rgba(45, 95, 95, 0.2);
 }
 
 /* Feature grid */
@@ -819,18 +961,43 @@ body {
   border: var(--border-width) solid var(--eink-medium-gray);
   border-radius: var(--border-radius-lg);
   padding: var(--spacing-xl);
-  transition: all var(--transition-fast);
+  transition: all 0.3s cubic-bezier(0.16, 1, 0.3, 1);
+  position: relative;
+  overflow: hidden;
+  transform: translateY(0);
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.05);
+}
+
+.feature-card::before {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: -100%;
+  width: 100%;
+  height: 100%;
+  background: linear-gradient(90deg, transparent, rgba(45, 95, 95, 0.05), transparent);
+  transition: left 0.5s ease;
 }
 
 .feature-card:hover {
   border-color: var(--accent-teal);
-  box-shadow: var(--shadow-md);
+  box-shadow: 0 8px 25px rgba(0, 0, 0, 0.12);
+  transform: translateY(-8px);
+}
+
+.feature-card:hover::before {
+  left: 100%;
+}
+
+.feature-card:hover .feature-icon {
+  transform: scale(1.1) rotate(5deg);
 }
 
 .feature-icon {
   font-size: var(--font-size-3xl);
   margin-bottom: var(--spacing-md);
   display: block;
+  transition: all 0.3s cubic-bezier(0.68, -0.55, 0.265, 1.55);
 }
 
 .feature-title {
@@ -860,20 +1027,65 @@ body {
   padding: var(--spacing-lg);
   text-decoration: none;
   color: inherit;
-  transition: all var(--transition-fast);
+  transition: all 0.3s cubic-bezier(0.16, 1, 0.3, 1);
   display: block;
+  position: relative;
+  overflow: hidden;
+  transform: translateY(0);
+  box-shadow: 0 2px 6px rgba(0, 0, 0, 0.05);
+}
+
+.docs-card::before {
+  content: '';
+  position: absolute;
+  bottom: 0;
+  left: 0;
+  width: 0;
+  height: 3px;
+  background-color: var(--accent-teal);
+  transition: width 0.3s ease;
+}
+
+.docs-card::after {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: -100%;
+  width: 100%;
+  height: 100%;
+  background: linear-gradient(90deg, transparent, rgba(45, 95, 95, 0.03), transparent);
+  transition: left 0.5s ease;
 }
 
 .docs-card:hover {
   border-color: var(--accent-teal);
-  box-shadow: var(--shadow-sm);
+  box-shadow: 0 6px 20px rgba(0, 0, 0, 0.1);
   text-decoration: none;
+  transform: translateY(-4px);
+}
+
+.docs-card:hover::before {
+  width: 100%;
+}
+
+.docs-card:hover::after {
+  left: 100%;
+}
+
+.docs-card:hover .docs-card-icon {
+  transform: scale(1.1);
+}
+
+.docs-card:active {
+  transform: translateY(-2px);
+  transition: all 0.1s ease;
 }
 
 .docs-card-icon {
   font-size: var(--font-size-2xl);
   margin-bottom: var(--spacing-sm);
   display: block;
+  transition: all 0.3s cubic-bezier(0.68, -0.55, 0.265, 1.55);
 }
 
 .docs-card-title {
@@ -1115,10 +1327,82 @@ textarea:focus {
   }
 }
 
+@keyframes fadeIn {
+  from {
+    opacity: 0;
+    transform: translateY(20px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+@keyframes slideDown {
+  from {
+    opacity: 0;
+    transform: translateY(-10px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+@keyframes scaleIn {
+  from {
+    opacity: 0;
+    transform: scale(0.9);
+  }
+  to {
+    opacity: 1;
+    transform: scale(1);
+  }
+}
+
+@keyframes shake {
+  0%, 100% { transform: translateX(0); }
+  25% { transform: translateX(-2px); }
+  75% { transform: translateX(2px); }
+}
+
+@keyframes bounce {
+  0%, 20%, 50%, 80%, 100% {
+    transform: translateY(0);
+  }
+  40% {
+    transform: translateY(-4px);
+  }
+  60% {
+    transform: translateY(-2px);
+  }
+}
+
+@keyframes spinOnce {
+  from {
+    transform: rotate(0deg);
+  }
+  to {
+    transform: rotate(360deg);
+  }
+}
+
 .loading {
   animation: pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite;
 }
 
+.fade-in {
+  animation: fadeIn 0.4s cubic-bezier(0.16, 1, 0.3, 1);
+}
+
+.slide-down {
+  animation: slideDown 0.3s cubic-bezier(0.16, 1, 0.3, 1);
+}
+
+.scale-in {
+  animation: scaleIn 0.2s cubic-bezier(0.16, 1, 0.3, 1);
+}
+
 /* Syntax highlighting (Rouge) */
 .highlight {
   background-color: var(--eink-white);
diff --git a/assets/js/main.js b/assets/js/main.js
index bfc6f47..2f2ae34 100644
--- a/assets/js/main.js
+++ b/assets/js/main.js
@@ -19,6 +19,7 @@
         initializeNavigation();
         initializeScrollSpy();
         initializeTableOfContents();
+        initializeMicroAnimations();
     }
 
     // Search functionality
@@ -563,4 +564,334 @@
         }
     };
 
+    // Micro-animations and interactive enhancements
+    function initializeMicroAnimations() {
+        // Enhanced button interactions
+        const buttons = document.querySelectorAll('.btn, .search-toggle, .bookmark-toggle, .menu-toggle');
+        buttons.forEach(button => {
+            // Add ripple effect on click
+            button.addEventListener('click', function(e) {
+                const ripple = document.createElement('span');
+                const rect = this.getBoundingClientRect();
+                const size = Math.max(rect.width, rect.height);
+                const x = e.clientX - rect.left - size / 2;
+                const y = e.clientY - rect.top - size / 2;
+                
+                ripple.style.cssText = `
+                    position: absolute;
+                    border-radius: 50%;
+                    background: rgba(255, 255, 255, 0.3);
+                    transform: scale(0);
+                    animation: ripple 0.6s linear;
+                    width: ${size}px;
+                    height: ${size}px;
+                    left: ${x}px;
+                    top: ${y}px;
+                    pointer-events: none;
+                `;
+                
+                // Ensure button has relative positioning for ripple
+                const computedStyle = window.getComputedStyle(this);
+                if (computedStyle.position === 'static') {
+                    this.style.position = 'relative';
+                }
+                
+                this.appendChild(ripple);
+                
+                // Remove ripple after animation
+                setTimeout(() => {
+                    if (ripple.parentNode) {
+                        ripple.parentNode.removeChild(ripple);
+                    }
+                }, 600);
+            });
+            
+            // Add loading state for primary buttons
+            if (button.classList.contains('btn-primary')) {
+                button.addEventListener('click', function() {
+                    if (this.dataset.loading === 'true') return;
+                    
+                    const originalText = this.textContent;
+                    this.dataset.loading = 'true';
+                    this.textContent = 'Loading...';
+                    this.classList.add('loading');
+                    
+                    // Reset after 2 seconds (simulating async operation)
+                    setTimeout(() => {
+                        this.dataset.loading = 'false';
+                        this.textContent = originalText;
+                        this.classList.remove('loading');
+                    }, 2000);
+                });
+            }
+        });
+
+        // Enhanced search input interactions
+        const searchInput = document.getElementById('search-input');
+        if (searchInput) {
+            let isSearching = false;
+            
+            searchInput.addEventListener('input', function() {
+                if (!isSearching && this.value.length > 0) {
+                    isSearching = true;
+                    this.classList.add('searching');
+                }
+            });
+            
+            // Clear searching state when no results or empty
+            const originalSearch = window.performSearch;
+            if (originalSearch) {
+                window.performSearch = function(query) {
+                    originalSearch(query);
+                    if (searchInput) {
+                        searchInput.classList.remove('searching');
+                        isSearching = false;
+                    }
+                };
+            }
+        }
+
+        // Enhanced card hover effects with stagger animation
+        const cards = document.querySelectorAll('.feature-card, .docs-card');
+        const observerOptions = {
+            threshold: 0.1,
+            rootMargin: '0px 0px -50px 0px'
+        };
+
+        const cardObserver = new IntersectionObserver((entries) => {
+            entries.forEach((entry, index) => {
+                if (entry.isIntersecting) {
+                    // Stagger the animation
+                    setTimeout(() => {
+                        entry.target.classList.add('fade-in');
+                        entry.target.style.animationDelay = `${index * 0.1}s`;
+                    }, index * 50);
+                    cardObserver.unobserve(entry.target);
+                }
+            });
+        }, observerOptions);
+
+        cards.forEach((card, index) => {
+            // Initial state
+            card.style.opacity = '0';
+            card.style.transform = 'translateY(20px)';
+            
+            cardObserver.observe(card);
+            
+            // Add magnetic effect on mouse move
+            card.addEventListener('mousemove', function(e) {
+                const rect = this.getBoundingClientRect();
+                const x = e.clientX - rect.left - rect.width / 2;
+                const y = e.clientY - rect.top - rect.height / 2;
+                
+                const moveX = x * 0.1;
+                const moveY = y * 0.1;
+                
+                this.style.transform = `translateY(-8px) rotateX(${-moveY}deg) rotateY(${moveX}deg)`;
+            });
+            
+            card.addEventListener('mouseleave', function() {
+                this.style.transform = 'translateY(0) rotateX(0) rotateY(0)';
+            });
+        });
+
+        // Enhanced navigation link interactions
+        const navLinks = document.querySelectorAll('.nav-link, .docs-nav-link');
+        navLinks.forEach(link => {
+            link.addEventListener('mouseenter', function() {
+                // Add pulse effect to active indicator
+                if (this.classList.contains('active')) {
+                    const indicator = this.querySelector('::after');
+                    this.style.setProperty('--pulse-animation', 'pulse 0.5s ease');
+                }
+            });
+        });
+
+        // Smooth scroll for all internal links
+        const internalLinks = document.querySelectorAll('a[href^="#"], a[href^="/"]');
+        internalLinks.forEach(link => {
+            if (link.hostname === window.location.hostname) {
+                link.addEventListener('click', function(e) {
+                    const href = this.getAttribute('href');
+                    if (href.startsWith('#')) {
+                        e.preventDefault();
+                        const target = document.querySelector(href);
+                        if (target) {
+                            target.scrollIntoView({
+                                behavior: 'smooth',
+                                block: 'start'
+                            });
+                            
+                            // Add highlight effect to target
+                            target.classList.add('highlight-target');
+                            setTimeout(() => {
+                                target.classList.remove('highlight-target');
+                            }, 2000);
+                        }
+                    }
+                });
+            }
+        });
+
+        // Add progressive enhancement for form elements
+        const inputs = document.querySelectorAll('input, textarea, select');
+        inputs.forEach(input => {
+            // Floating label effect
+            const label = input.previousElementSibling;
+            if (label && label.tagName === 'LABEL') {
+                input.addEventListener('focus', () => {
+                    label.classList.add('focused');
+                });
+                
+                input.addEventListener('blur', () => {
+                    if (!input.value) {
+                        label.classList.remove('focused');
+                    }
+                });
+                
+                // Check initial state
+                if (input.value) {
+                    label.classList.add('focused');
+                }
+            }
+            
+            // Add validation feedback
+            input.addEventListener('invalid', function() {
+                this.classList.add('error');
+                this.style.animation = 'shake 0.5s ease-in-out';
+            });
+            
+            input.addEventListener('input', function() {
+                this.classList.remove('error');
+                this.style.animation = '';
+            });
+        });
+
+        // Enhanced scroll indicators
+        const scrollIndicator = document.createElement('div');
+        scrollIndicator.className = 'scroll-indicator';
+        scrollIndicator.innerHTML = '<div class="scroll-progress"></div>';
+        document.body.appendChild(scrollIndicator);
+        
+        const scrollProgress = scrollIndicator.querySelector('.scroll-progress');
+        
+        window.addEventListener('scroll', throttle(() => {
+            const winScroll = document.body.scrollTop || document.documentElement.scrollTop;
+            const height = document.documentElement.scrollHeight - document.documentElement.clientHeight;
+            const scrolled = (winScroll / height) * 100;
+            
+            scrollProgress.style.width = scrolled + '%';
+            
+            // Add scroll-based animations
+            if (winScroll > 100) {
+                document.body.classList.add('scrolled');
+            } else {
+                document.body.classList.remove('scrolled');
+            }
+        }, 10));
+
+        // Add CSS for animations
+        const animationStyles = document.createElement('style');
+        animationStyles.textContent = `
+            @keyframes ripple {
+                to {
+                    transform: scale(4);
+                    opacity: 0;
+                }
+            }
+            
+            @keyframes fadeInUp {
+                from {
+                    opacity: 0;
+                    transform: translateY(30px);
+                }
+                to {
+                    opacity: 1;
+                    transform: translateY(0);
+                }
+            }
+            
+            .fade-in {
+                animation: fadeInUp 0.6s cubic-bezier(0.16, 1, 0.3, 1) forwards;
+            }
+            
+            .searching {
+                position: relative;
+            }
+            
+            .searching::after {
+                content: '';
+                position: absolute;
+                right: 10px;
+                top: 50%;
+                transform: translateY(-50%);
+                width: 16px;
+                height: 16px;
+                border: 2px solid var(--eink-light-gray);
+                border-top: 2px solid var(--accent-teal);
+                border-radius: 50%;
+                animation: spinOnce 1s linear infinite;
+            }
+            
+            .highlight-target {
+                background-color: rgba(45, 95, 95, 0.1);
+                transition: background-color 0.3s ease;
+                border-radius: 4px;
+                padding: 0.5rem;
+                margin: -0.5rem;
+            }
+            
+            .scroll-indicator {
+                position: fixed;
+                top: 0;
+                left: 0;
+                width: 100%;
+                height: 3px;
+                background-color: var(--eink-light-gray);
+                z-index: 1000;
+                opacity: 0;
+                transition: opacity 0.3s ease;
+            }
+            
+            .scrolled .scroll-indicator {
+                opacity: 1;
+            }
+            
+            .scroll-progress {
+                height: 100%;
+                background: linear-gradient(90deg, var(--accent-teal), var(--accent-teal-light));
+                width: 0%;
+                transition: width 0.1s ease;
+            }
+            
+            .floating-label {
+                position: relative;
+            }
+            
+            .floating-label label {
+                position: absolute;
+                top: 50%;
+                left: 10px;
+                transform: translateY(-50%);
+                transition: all 0.3s ease;
+                pointer-events: none;
+                color: var(--eink-charcoal);
+            }
+            
+            .floating-label label.focused {
+                top: -10px;
+                font-size: 0.75rem;
+                color: var(--accent-teal);
+                background: var(--eink-white);
+                padding: 0 5px;
+            }
+            
+            .error {
+                border-color: #e74c3c !important;
+                box-shadow: 0 0 0 2px rgba(231, 76, 60, 0.2) !important;
+            }
+        `;
+        document.head.appendChild(animationStyles);
+    }
+
 })();
\ No newline at end of file

From d21063b4112217ac6b9972b897eb52444d02d1a5 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 28 Jul 2025 19:42:07 +0000
Subject: [PATCH 4/6] Update documentation for 73+ methods, add JSON-RPC API
 support, and implement floating LLMs.txt button

Co-authored-by: 0xrinegade <101195284+0xrinegade@users.noreply.github.com>
---
 _docs/API_REFERENCE.md |  41 ++++++-
 _layouts/default.html  |   9 ++
 assets/css/main.css    | 144 ++++++++++++++++++++++
 assets/js/main.js      | 263 +++++++++++++++++++++++++++++++++++++++++
 index.md               |   8 +-
 5 files changed, 459 insertions(+), 6 deletions(-)

diff --git a/_docs/API_REFERENCE.md b/_docs/API_REFERENCE.md
index 046fe4a..5c5d7c0 100644
--- a/_docs/API_REFERENCE.md
+++ b/_docs/API_REFERENCE.md
@@ -1,7 +1,7 @@
 ---
 layout: docs
 title: "API Reference"
-description: "Complete documentation of all 47 RPC methods with parameters, examples, and response formats"
+description: "Complete documentation of all 73+ RPC methods with parameters, examples, and response formats including JSON-RPC 2.0 support"
 order: 3
 category: api
 ---
@@ -10,7 +10,44 @@ category: api
 
 ## Overview
 
-The Solana MCP Server exposes 47 comprehensive RPC methods across 6 major categories, plus 4 network management methods. All methods support both single-network and multi-network execution modes.
+The Solana MCP Server exposes 73+ comprehensive RPC methods across 6 major categories, plus 4 network management methods and 18 WebSocket subscription methods. All methods support both single-network and multi-network execution modes with full JSON-RPC 2.0 compatibility.
+
+## JSON-RPC 2.0 API Support
+
+The server provides complete JSON-RPC 2.0 API compatibility when running in web service mode:
+
+### HTTP Mode
+- **Endpoint**: `http://localhost:3000` (configurable port)
+- **Method**: POST with `Content-Type: application/json`
+- **Format**: Standard JSON-RPC 2.0 request/response
+
+```bash
+# Example HTTP request
+curl -X POST http://localhost:3000 \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 1,
+    "method": "getBalance",
+    "params": ["Gh9ZwEmdLJ8DscKNTkTqPbNwLNNBjuSzaG9Vp2KGtKJr"]
+  }'
+```
+
+### WebSocket Mode
+- **Endpoint**: `ws://localhost:8900` (configurable port)
+- **Format**: JSON-RPC 2.0 with subscription support
+- **Features**: Real-time account, block, transaction, and program subscriptions
+
+```javascript
+// Example WebSocket subscription
+const ws = new WebSocket('ws://localhost:8900');
+ws.send(JSON.stringify({
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "accountSubscribe",
+  "params": ["11111111111111111111111111111111"]
+}));
+```
 
 ## Network Management Methods
 
diff --git a/_layouts/default.html b/_layouts/default.html
index 6dfde93..1b96dd9 100644
--- a/_layouts/default.html
+++ b/_layouts/default.html
@@ -201,6 +201,15 @@ <h1 class="page-title">{{ page.title }}</h1>
         </div>
     </footer>
     
+    <!-- Floating LLMs.txt Button -->
+    <button class="llms-floating-btn" id="llms-floating-btn" aria-label="Copy LLMs.txt content" title="Copy LLMs.txt content to clipboard">
+        <svg class="llms-icon" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect>
+            <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path>
+        </svg>
+        <span class="llms-text">LLMs.txt</span>
+    </button>
+    
     <!-- JavaScript -->
     <script src="{{ '/assets/js/main.js' | relative_url }}"></script>
     
diff --git a/assets/css/main.css b/assets/css/main.css
index 21b5f1d..80e91fa 100644
--- a/assets/css/main.css
+++ b/assets/css/main.css
@@ -1417,4 +1417,148 @@ textarea:focus {
 .highlight .k { color: var(--accent-teal); font-weight: bold; } /* Keyword */
 .highlight .s { color: var(--accent-amber); } /* String */
 .highlight .nb { color: var(--accent-teal); } /* Name.Builtin */
+
+/* Floating LLMs.txt Button */
+.llms-floating-btn {
+  position: fixed;
+  bottom: 30px;
+  right: 30px;
+  background-color: var(--accent-teal);
+  color: var(--eink-white);
+  border: none;
+  border-radius: 50px;
+  padding: 12px 20px;
+  cursor: pointer;
+  font-size: var(--font-size-sm);
+  font-weight: var(--font-weight-medium);
+  font-family: var(--font-family-sans);
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  box-shadow: 0 4px 16px rgba(45, 95, 95, 0.3);
+  transition: all 0.3s cubic-bezier(0.16, 1, 0.3, 1);
+  z-index: 1000;
+  transform: translateY(0);
+  min-width: 120px;
+  overflow: hidden;
+}
+
+.llms-floating-btn::before {
+  content: '';
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  width: 0;
+  height: 0;
+  background-color: rgba(255, 255, 255, 0.2);
+  border-radius: 50%;
+  transform: translate(-50%, -50%);
+  transition: all 0.3s ease;
+  z-index: -1;
+}
+
+.llms-floating-btn:hover {
+  background-color: var(--accent-teal-light);
+  box-shadow: 0 6px 20px rgba(45, 95, 95, 0.4);
+  transform: translateY(-2px) scale(1.05);
+}
+
+.llms-floating-btn:hover::before {
+  width: 200px;
+  height: 200px;
+}
+
+.llms-floating-btn:active {
+  transform: translateY(0) scale(0.98);
+  box-shadow: 0 4px 16px rgba(45, 95, 95, 0.3);
+  transition: all 0.1s ease;
+}
+
+.llms-floating-btn.copying {
+  background-color: var(--accent-amber);
+  animation: pulse 0.5s ease;
+}
+
+.llms-floating-btn.copied {
+  background-color: #22c55e;
+  animation: bounce 0.6s ease;
+}
+
+.llms-icon {
+  transition: all 0.3s cubic-bezier(0.68, -0.55, 0.265, 1.55);
+  flex-shrink: 0;
+}
+
+.llms-floating-btn:hover .llms-icon {
+  transform: scale(1.1) rotate(5deg);
+}
+
+.llms-text {
+  font-size: var(--font-size-xs);
+  font-weight: var(--font-weight-semibold);
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+  transition: all 0.3s ease;
+}
+
+/* Mobile responsive */
+@media (max-width: 768px) {
+  .llms-floating-btn {
+    bottom: 20px;
+    right: 20px;
+    padding: 10px 16px;
+    min-width: 100px;
+  }
+  
+  .llms-text {
+    font-size: 10px;
+  }
+  
+  .llms-icon {
+    width: 16px;
+    height: 16px;
+  }
+}
+
+@media (max-width: 480px) {
+  .llms-floating-btn {
+    bottom: 15px;
+    right: 15px;
+    padding: 8px 12px;
+    min-width: 80px;
+  }
+  
+  .llms-text {
+    display: none;
+  }
+}
+
+/* Accessibility for reduced motion */
+@media (prefers-reduced-motion: reduce) {
+  .llms-floating-btn {
+    transition: none;
+    animation: none;
+  }
+  
+  .llms-floating-btn:hover {
+    transform: none;
+  }
+  
+  .llms-floating-btn:active {
+    transform: none;
+  }
+}
+
+/* High contrast mode */
+@media (prefers-contrast: high) {
+  .llms-floating-btn {
+    border: 2px solid var(--eink-white);
+    background-color: var(--eink-black);
+    color: var(--eink-white);
+  }
+  
+  .llms-floating-btn:hover {
+    background-color: var(--eink-dark-charcoal);
+  }
+}
 .highlight .nf { color: var(--eink-dark-charcoal); font-weight: bold; } /* Name.Function */
\ No newline at end of file
diff --git a/assets/js/main.js b/assets/js/main.js
index 2f2ae34..e89a4da 100644
--- a/assets/js/main.js
+++ b/assets/js/main.js
@@ -20,6 +20,7 @@
         initializeScrollSpy();
         initializeTableOfContents();
         initializeMicroAnimations();
+        initializeLLMsButton();
     }
 
     // Search functionality
@@ -894,4 +895,266 @@
         document.head.appendChild(animationStyles);
     }
 
+    // LLMs.txt floating button functionality
+    function initializeLLMsButton() {
+        const llmsButton = document.getElementById('llms-floating-btn');
+        if (!llmsButton) return;
+        
+        let llmsContent = null;
+        
+        // Fetch the llms.txt content
+        async function fetchLLMsContent() {
+            if (llmsContent) return llmsContent;
+            
+            try {
+                const response = await fetch('/llms.txt');
+                if (response.ok) {
+                    llmsContent = await response.text();
+                    return llmsContent;
+                } else {
+                    throw new Error('Failed to fetch llms.txt');
+                }
+            } catch (error) {
+                console.error('Error fetching llms.txt:', error);
+                return 'LLMs.txt content not available';
+            }
+        }
+        
+        // Copy to clipboard functionality
+        async function copyToClipboard(text) {
+            try {
+                if (navigator.clipboard && window.isSecureContext) {
+                    await navigator.clipboard.writeText(text);
+                    return true;
+                } else {
+                    // Fallback for older browsers or non-secure contexts
+                    const textArea = document.createElement('textarea');
+                    textArea.value = text;
+                    textArea.style.position = 'fixed';
+                    textArea.style.left = '-999999px';
+                    textArea.style.top = '-999999px';
+                    document.body.appendChild(textArea);
+                    textArea.focus();
+                    textArea.select();
+                    
+                    const success = document.execCommand('copy');
+                    document.body.removeChild(textArea);
+                    return success;
+                }
+            } catch (err) {
+                console.error('Failed to copy text: ', err);
+                return false;
+            }
+        }
+        
+        // Button click handler
+        llmsButton.addEventListener('click', async function() {
+            // Prevent multiple clicks
+            if (this.classList.contains('copying') || this.classList.contains('copied')) {
+                return;
+            }
+            
+            // Show copying state
+            this.classList.add('copying');
+            const originalText = this.querySelector('.llms-text').textContent;
+            this.querySelector('.llms-text').textContent = 'Copying...';
+            
+            try {
+                // Fetch and copy content
+                const content = await fetchLLMsContent();
+                const success = await copyToClipboard(content);
+                
+                // Update button state
+                this.classList.remove('copying');
+                
+                if (success) {
+                    this.classList.add('copied');
+                    this.querySelector('.llms-text').textContent = 'Copied!';
+                    
+                    // Show success toast
+                    showToast('LLMs.txt content copied to clipboard!', 'success');
+                    
+                    // Track the action
+                    if (typeof gtag !== 'undefined') {
+                        gtag('event', 'llms_copy', {
+                            event_category: 'Engagement',
+                            event_label: 'llms.txt',
+                            value: content.length
+                        });
+                    }
+                } else {
+                    this.querySelector('.llms-text').textContent = 'Failed';
+                    showToast('Failed to copy content. Please try again.', 'error');
+                }
+                
+                // Reset button after 2 seconds
+                setTimeout(() => {
+                    this.classList.remove('copied');
+                    this.querySelector('.llms-text').textContent = originalText;
+                }, 2000);
+                
+            } catch (error) {
+                console.error('Error copying LLMs content:', error);
+                this.classList.remove('copying');
+                this.querySelector('.llms-text').textContent = 'Error';
+                showToast('Error occurred while copying. Please try again.', 'error');
+                
+                setTimeout(() => {
+                    this.querySelector('.llms-text').textContent = originalText;
+                }, 2000);
+            }
+        });
+        
+        // Add hover effects
+        llmsButton.addEventListener('mouseenter', function() {
+            if (!this.classList.contains('copying') && !this.classList.contains('copied')) {
+                this.style.transform = 'translateY(-2px) scale(1.05)';
+            }
+        });
+        
+        llmsButton.addEventListener('mouseleave', function() {
+            if (!this.classList.contains('copying') && !this.classList.contains('copied')) {
+                this.style.transform = 'translateY(0) scale(1)';
+            }
+        });
+        
+        // Keyboard accessibility
+        llmsButton.addEventListener('keydown', function(e) {
+            if (e.key === 'Enter' || e.key === ' ') {
+                e.preventDefault();
+                this.click();
+            }
+        });
+    }
+    
+    // Toast notification function
+    function showToast(message, type = 'info') {
+        // Remove existing toast if any
+        const existingToast = document.querySelector('.toast-notification');
+        if (existingToast) {
+            existingToast.remove();
+        }
+        
+        // Create toast element
+        const toast = document.createElement('div');
+        toast.className = `toast-notification toast-${type}`;
+        toast.innerHTML = `
+            <div class="toast-content">
+                <span class="toast-icon">${type === 'success' ? '✓' : type === 'error' ? '✗' : 'ℹ'}</span>
+                <span class="toast-message">${message}</span>
+            </div>
+        `;
+        
+        // Add toast styles
+        const toastStyles = `
+            .toast-notification {
+                position: fixed;
+                top: 20px;
+                right: 20px;
+                background: var(--eink-white);
+                border: 1px solid var(--eink-medium-gray);
+                border-radius: var(--border-radius-md);
+                padding: var(--spacing-md);
+                box-shadow: var(--shadow-lg);
+                z-index: 10000;
+                opacity: 0;
+                transform: translateX(100%);
+                transition: all 0.3s cubic-bezier(0.16, 1, 0.3, 1);
+                max-width: 300px;
+                font-family: var(--font-family-sans);
+            }
+            
+            .toast-notification.show {
+                opacity: 1;
+                transform: translateX(0);
+            }
+            
+            .toast-success {
+                border-left: 4px solid #22c55e;
+            }
+            
+            .toast-error {
+                border-left: 4px solid #ef4444;
+            }
+            
+            .toast-info {
+                border-left: 4px solid var(--accent-teal);
+            }
+            
+            .toast-content {
+                display: flex;
+                align-items: center;
+                gap: var(--spacing-sm);
+            }
+            
+            .toast-icon {
+                font-weight: bold;
+                font-size: var(--font-size-lg);
+            }
+            
+            .toast-success .toast-icon {
+                color: #22c55e;
+            }
+            
+            .toast-error .toast-icon {
+                color: #ef4444;
+            }
+            
+            .toast-info .toast-icon {
+                color: var(--accent-teal);
+            }
+            
+            .toast-message {
+                font-size: var(--font-size-sm);
+                color: var(--eink-dark-charcoal);
+                line-height: var(--line-height-normal);
+            }
+            
+            @media (max-width: 768px) {
+                .toast-notification {
+                    top: 10px;
+                    right: 10px;
+                    left: 10px;
+                    max-width: none;
+                }
+            }
+        `;
+        
+        // Add styles if not already added
+        if (!document.querySelector('#toast-styles')) {
+            const styleElement = document.createElement('style');
+            styleElement.id = 'toast-styles';
+            styleElement.textContent = toastStyles;
+            document.head.appendChild(styleElement);
+        }
+        
+        // Add to document
+        document.body.appendChild(toast);
+        
+        // Trigger animation
+        requestAnimationFrame(() => {
+            toast.classList.add('show');
+        });
+        
+        // Auto remove after 3 seconds
+        setTimeout(() => {
+            toast.classList.remove('show');
+            setTimeout(() => {
+                if (toast.parentNode) {
+                    toast.parentNode.removeChild(toast);
+                }
+            }, 300);
+        }, 3000);
+        
+        // Allow manual dismiss by clicking
+        toast.addEventListener('click', () => {
+            toast.classList.remove('show');
+            setTimeout(() => {
+                if (toast.parentNode) {
+                    toast.parentNode.removeChild(toast);
+                }
+            }, 300);
+        });
+    }
+
 })();
\ No newline at end of file
diff --git a/index.md b/index.md
index 50ef2c0..03608f5 100644
--- a/index.md
+++ b/index.md
@@ -21,7 +21,7 @@ description: "A comprehensive Model Context Protocol server for seamless Solana
     <span class="feature-icon">🚀</span>
     <h3 class="feature-title">Comprehensive RPC Coverage</h3>
     <p class="feature-description">
-      47 Solana RPC methods across all major categories including accounts, blocks, transactions, tokens, and system operations. Real-time blockchain data with configurable commitment levels.
+      73+ Solana RPC methods across all major categories including accounts, blocks, transactions, tokens, and system operations. Real-time blockchain data with configurable commitment levels plus full WebSocket subscription support.
     </p>
   </div>
   
@@ -90,7 +90,7 @@ description: "A comprehensive Model Context Protocol server for seamless Solana
       <span class="docs-card-icon">📖</span>
       <h3 class="docs-card-title">API Reference</h3>
       <p class="docs-card-description">
-        Complete documentation of all 47 RPC methods with parameters, examples, and response formats.
+        Complete documentation of all 73+ RPC methods with parameters, examples, and response formats including JSON-RPC API support.
       </p>
     </a>
     
@@ -120,9 +120,9 @@ description: "A comprehensive Model Context Protocol server for seamless Solana
     
     <a href="{{ '/docs/web-service/' | relative_url }}" class="docs-card">
       <span class="docs-card-icon">🌐</span>
-      <h3 class="docs-card-title">Web Service</h3>
+      <h3 class="docs-card-title">Web Service & JSON-RPC</h3>
       <p class="docs-card-description">
-        HTTP API mode with JSON-RPC endpoints, health checks, and Prometheus metrics integration.
+        HTTP API mode with JSON-RPC 2.0 endpoints, WebSocket subscriptions, health checks, and Prometheus metrics integration.
       </p>
     </a>
     

From 580a9c9c0016a4403c63a870efd4860812531fdd Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Mon, 28 Jul 2025 19:50:30 +0000
Subject: [PATCH 5/6] Add /llms.txt endpoint to serve LLM documentation file

Co-authored-by: 0xrinegade <0xrinegade@gmail.com>
---
 src/http_server.rs | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/src/http_server.rs b/src/http_server.rs
index 9405253..edc0fe4 100644
--- a/src/http_server.rs
+++ b/src/http_server.rs
@@ -64,6 +64,7 @@ impl McpHttpServer {
                 .route("/metrics", get(metrics_handler))
                 .route("/health", get(health_handler))
                 .route("/api/mcp", post(mcp_api_handler))
+                .route("/llms.txt", get(llms_txt_handler))
                 .with_state(state.clone())
                 .layer(ServiceBuilder::new()
                     .layer(TimeoutLayer::new(http_timeout))
@@ -73,6 +74,7 @@ impl McpHttpServer {
             Router::new()
                 .route("/metrics", get(metrics_handler))
                 .route("/health", get(health_handler))
+                .route("/llms.txt", get(llms_txt_handler))
                 .layer(ServiceBuilder::new()
                     .layer(TimeoutLayer::new(http_timeout))
                 )
@@ -181,6 +183,26 @@ async fn mcp_api_handler(
     }
 }
 
+/// Handler for /llms.txt endpoint - serves the LLM documentation file
+async fn llms_txt_handler() -> Response {
+    match tokio::fs::read_to_string("llms.txt").await {
+        Ok(content) => {
+            (
+                StatusCode::OK,
+                [("content-type", "text/plain; charset=utf-8")],
+                content,
+            ).into_response()
+        }
+        Err(e) => {
+            error!("Failed to read llms.txt: {}", e);
+            (
+                StatusCode::NOT_FOUND,
+                "LLMs.txt file not found",
+            ).into_response()
+        }
+    }
+}
+
 /// Parse and validate JSON-RPC 2.0 request according to MCP specification
 fn parse_json_rpc_request(request: &serde_json::Value) -> Result<JsonRpcRequest, Box<Response>> {
     // Validate required fields for JSON-RPC 2.0
@@ -315,4 +337,11 @@ mod tests {
         // This test ensures the function signature is correct and compiles
         // Real integration tests would be in a separate test file with proper setup
     }
+
+    #[tokio::test]
+    async fn test_llms_txt_handler() {
+        let response = llms_txt_handler().await;
+        // The response should be either OK (if file exists) or NOT_FOUND (if file doesn't exist)
+        // This test ensures the handler doesn't panic and returns a valid response
+    }
 }
\ No newline at end of file

From 7c0af85a5364c55b61d2f6750a836d69fac2e5aa Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Mon, 28 Jul 2025 20:01:19 +0000
Subject: [PATCH 6/6] Make search and bookmark functions globally accessible

Co-authored-by: 0xrinegade <0xrinegade@gmail.com>
---
 assets/js/main.js | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)

diff --git a/assets/js/main.js b/assets/js/main.js
index e89a4da..5419b38 100644
--- a/assets/js/main.js
+++ b/assets/js/main.js
@@ -23,6 +23,10 @@
         initializeLLMsButton();
     }
 
+    // Global functions that need to be accessible outside their initialization scopes
+    let performSearch = null;
+    let toggleBookmark = null;
+
     // Search functionality
     function initializeSearch() {
         const searchToggle = document.getElementById('search-toggle');
@@ -97,7 +101,8 @@
             }, 150);
         });
 
-        function performSearch(query) {
+        // Define performSearch and assign to global variable
+        performSearch = function(query) {
             if (!searchIndex) {
                 searchResults.innerHTML = '<div class="search-result"><div class="search-result-title">Search not available</div></div>';
                 return;
@@ -110,7 +115,7 @@
                 console.error('Search error:', e);
                 searchResults.innerHTML = '<div class="search-result"><div class="search-result-title">Search error occurred</div></div>';
             }
-        }
+        };
 
         function displaySearchResults(results, query) {
             if (results.length === 0) {
@@ -197,7 +202,8 @@
             toggleBookmark(currentUrl, currentTitle);
         });
 
-        function toggleBookmark(url, title) {
+        // Define toggleBookmark and assign to global variable
+        toggleBookmark = function(url, title) {
             let bookmarks = JSON.parse(localStorage.getItem('solana-mcp-bookmarks') || '[]');
             const existingIndex = bookmarks.findIndex(b => b.url === url);
 
@@ -219,7 +225,7 @@
 
             localStorage.setItem('solana-mcp-bookmarks', JSON.stringify(bookmarks));
             window.bookmarks = bookmarks;
-        }
+        };
 
         function updateBookmarkIcon() {
             const bookmarks = JSON.parse(localStorage.getItem('solana-mcp-bookmarks') || '[]');
@@ -556,8 +562,8 @@
 
     // Export for global access
     window.SolanaMCPDocs = {
-        search: performSearch,
-        toggleBookmark: (url, title) => toggleBookmark(url, title),
+        search: (query) => performSearch && performSearch(query),
+        toggleBookmark: (url, title) => toggleBookmark && toggleBookmark(url, title),
         getBookmarks: () => JSON.parse(localStorage.getItem('solana-mcp-bookmarks') || '[]'),
         clearBookmarks: () => {
             localStorage.removeItem('solana-mcp-bookmarks');
@@ -565,6 +571,9 @@
         }
     };
 
+    // Also expose performSearch globally for backward compatibility
+    window.performSearch = (query) => performSearch && performSearch(query);
+
     // Micro-animations and interactive enhancements
     function initializeMicroAnimations() {
         // Enhanced button interactions