Rest of docs (#3339)

* add enterprise section to new docs

* changeset

* migrate mcp docs

* changeset

* migrate more info section

* changeset

* reorder entries

---------

Co-authored-by: Elephant Lumps <[email protected]>
Co-authored-by: Elephant Lumps <[email protected]>
Co-authored-by: Elephant Lumps <[email protected]>

.changeset/long-worms-search.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Migrate more info section to new docs

.changeset/shiny-falcons-hope.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Add enterprise section to new docs

.changeset/thirty-needles-tie.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Migrate MCP section to new docs

docs/docs.json

@@ -67,12 +67,8 @@
 				]
 			},
 			{
-				"group": "Running Models Locally",
-				"pages": [
-					"running-models-locally/read-me-first",
-					"running-models-locally/lm-studio",
-					"running-models-locally/ollama"
-				]
+				"group": "Improving Your Prompting Skills",
+				"pages": ["prompting/prompt-engineering-guide", "prompting/cline-memory-bank"]
 			},
 			{
 				"group": "Exploring Cline's Tools",
@@ -86,8 +82,25 @@
 				]
 			},
 			{
-				"group": "Improving Your Prompting Skills",
-				"pages": ["prompting/prompt-engineering-guide", "prompting/cline-memory-bank"]
+				"group": "Enterprise Solutions",
+				"pages": [
+					"enterprise-solutions/cloud-provider-integration",
+					"enterprise-solutions/custom-instructions",
+					"enterprise-solutions/mcp-servers",
+					"enterprise-solutions/security-concerns"
+				]
+			},
+			{
+				"group": "MCP Servers",
+				"pages": [
+					"mcp/mcp-overview",
+					"mcp/adding-mcp-servers-from-github",
+					"mcp/configuring-mcp-servers",
+					"mcp/connecting-to-a-remote-server",
+					"mcp/mcp-marketplace",
+					"mcp/mcp-server-development-protocol",
+					"mcp/mcp-transport-mechanisms"
+				]
 			},
 			{
 				"group": "Custom Model Configurations",
@@ -97,6 +110,18 @@
 					"custom-model-configs/gcp-vertex-ai",
 					"custom-model-configs/litellm-and-cline-using-codestral"
 				]
+			},
+			{
+				"group": "Running Models Locally",
+				"pages": [
+					"running-models-locally/read-me-first",
+					"running-models-locally/lm-studio",
+					"running-models-locally/ollama"
+				]
+			},
+			{
+				"group": "More Info",
+				"pages": ["more-info/telemetry"]
 			}
 		]
 	},

docs/enterprise-solutions/cloud-provider-integration.mdx

@@ -0,0 +1,39 @@
+---
+title: "Cloud Provider Integration"
+---
+
+Cline supports major cloud providers like AWS Bedrock and Google's Cloud Vertex; whichever your team currently uses is appropriate, and there's no need to change providers to utilize Cline's features.
+
+For the purpose of this document, we assume your organization will use cloud-based frontier models. Cloud inference providers offer cutting-edge capabilities and the flexibility to select models which best suit your needs.
+
+Certain scenarios may warrant using local models, including handling highly sensitive data, applications requiring consistent low-latency responses, or compliance with strict data sovereignty requirements. If your team needs to utilize local models, see [Running Local Models ](/running-local-models/read-me-first.mdx)with Cline.
+
+---
+
+## AWS Bedrock Setup Guides
+
+#### [IAM Security Best Practices](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) (For administrators)
+
+#### [AWS Bedrock setup for Legacy IAM (AWS Credentials)](/custom-model-configs/aws-bedrock.mdx)
+
+#### [AWS Bedrock setup for SSO token (AWS Profile)](/custom-model-configs/aws-bedrock-w-profile-authentication.mdx)
+
+#### VPC Endpoint Setup
+
+To protect your team's data, Cline supports VPC (Virtual Private Cloud) endpoints, which create private connections between your data and AWS Bedrock. AWS VPCs enhance security by eliminating the need for public IP addresses, network gateways, or complex firewall rules—essentially creating a private highway for data that bypasses the public internet entirely. By keeping traffic within AWS's private network, teams also benefit from lower latency and more predictable performance when accessing services like AWS Bedrock or custom APIs. For those working with confidential information or operating in highly regulated industries like healthcare or finance, VPCs offers the perfect balance between the accessibility of cloud services and the security of private infrastructure.
+
+---
+
+1. Consult the [AWS guide](https://docs.aws.amazon.com/bedrock/latest/userguide/vpc-interface-endpoints.html) to creating VPC endpoints. This document specifies pre-requisites and describes the syntax used for creating VPC endpoints.
+2. Follow the directions for [creating a VPC endpoint](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint-aws) in the AWS console. The image below pertains to steps 4 and 5 of the AWS guide linked above.
+
+<Frame>
+	<img src="/assets/robot_panel_dark.png" alt="VPC Console" />
+</Frame>
+
+3. Note the IP address of your VPC endpoint, open Cline's settings menu, and select `AWS Bedrock`from the API Provider dropdown.
+4. Click the `Use Custom VPC endpoint`checkbox and enter the IP address of your VPC endpoint
+
+<Frame>
+	<img src="/assets/robot_panel_dark.png" alt="VPC Settings Menu" />
+</Frame>

docs/enterprise-solutions/custom-instructions.mdx

@@ -0,0 +1,22 @@
+---
+title: "Custom Instructions"
+---
+
+## Building Custom Instructions for Teams
+
+**Creating standardized project instructions ensures that all team members work within consistent guidelines. Start by documenting your project's technical foundation, then identify which information needs to be included in the instructions. The exact scope will vary depending on your team's needs, but generally it's best to provide as much information as possible. By creating comprehensive instructions that all team members follow, you establish a shared understanding of how code should be written, tested, and deployed across your project, resulting in more maintainable and consistent software.**
+
+---
+
+Here are a few topics and examples to consider for your team's custom instructions:
+
+1. **Testing framework and specific commands**
+    - "All components must include Jest tests with at least 85% coverage. Run tests using `npm run test:coverage` before submitting any pull request."
+2. **Explicit library preferences**
+    - "Use React Query for data fetching and state management. Avoid Redux unless specifically required for complex global state. For styling, use Tailwind CSS with our custom theme configuration found in `src/styles/theme.js.`"
+3. **Where to find documentation**
+    - "All API documentation is available in our internal Notion workspace under 'Engineering > API Reference'. For component usage examples, refer to our Storybook instance at `https://storybook.internal.company.com`"
+4. **Which MCP servers to use, and for which purposes**
+    - "For database operations, use the Postgres MCP server with credentials stored in 1Password under 'Development > Database'. For deployments, use the AWS MCP server which requires the deployment role from IAM. Refer to `docs/mcp-setup.md` for configuration instructions."
+5. **Coding conventions specific to your project**
+    - "Name all React components using PascalCase and all helper functions using camelCase. Place components in the `src/components` directory organized by feature, not by type. Always use TypeScript interfaces for prop definitions."

docs/enterprise-solutions/mcp-servers.mdx

@@ -0,0 +1,25 @@
+---
+title: "MCP Servers"
+---
+
+**Model Context Protocol (MCP) servers expand Cline's capabilities by providing standardized access to external data sources and executable functions. By implementing MCP servers, LLM tools can dynamically retrieve and incorporate relevant information from both local and remote data sources. This capability ensures that the models operate with the most current and contextually appropriate data, improving the accuracy and relevance of their outputs.**
+
+---
+
+### Secure Architecture Fundamentals
+
+MCP servers follow a client-server architecture where hosts (LLM applications like Cline) initiate connections through a transport layer to MCP servers. This architecture inherently provides security benefits as it maintains clear separation between components. Enterprise deployments should focus on the proper implementation of this architecture to ensure secure operations, particularly regarding the message exchange patterns and connection lifecycle management. For MCP architecture details, see [MCP Architecture](https://modelcontextprotocol.io/docs/concepts/architecture), and for latest specifications, see [MCP Specifications](https://spec.modelcontextprotocol.io/specification/2024-11-05/).
+
+### Transport Layer Security
+
+For enterprise environments, selecting the appropriate transport mechanism is crucial. While stdio transport works efficiently for local processes, HTTP with Server-Sent Events (SSE) transport requires additional security measures. TLS should be used for all remote connections whenever possible. This is especially important when MCP servers are deployed across different network segments within corporate infrastructure.
+
+### Message Validation and Access Control
+
+The MCP architecture defines standard error codes and message types (Requests, Results, Errors, and Notifications), providing a structured framework for secure communication. Security teams should consider message validation, sanitizing inputs, checking message size limits, and verifying JSON-RPC format. Additionally, implementing resource protection through access controls, path validation, and request rate limiting helps prevent potential abuse of MCP server capabilities.
+
+### Monitoring and Compliance
+
+For enterprise compliance requirements, implementing comprehensive logging of protocol events, message flows, and errors is essential. The MCP architecture supports diagnostic capabilities including health checks, connection state monitoring, and resource usage tracking. Organizations should extend these capabilities to meet their specific compliance needs, particularly for audit trails of all MCP server interactions and resource access patterns.
+
+By leveraging the client-server design of the MCP architecture and implementing appropriate security controls at each layer, enterprises can safely integrate MCP servers into their environments while maintaining their security posture and meeting regulatory requirements.

docs/enterprise-solutions/security-concerns.mdx

@@ -0,0 +1,60 @@
+---
+title: "Security Concerns"
+---
+
+## Enterprise Security with Cline
+
+#### Cline addresses enterprise security concerns through its unique client-side architecture that prioritizes data privacy, secure cloud integration, and transparent operations. Below is a comprehensive overview of how Cline maintains robust security measures for enterprise environments.
+
+---
+
+### Client-Side Architecture
+
+Cline operates exclusively as a client-side VSCode extension with zero server-side components. This fundamental design choice ensures that your code and data remain within your secure environment at all times. Unlike traditional AI assistants that send data to external servers for processing, Cline connects directly to your chosen cloud provider's AI endpoints, keeping all sensitive information within your infrastructure boundaries.
+
+<Frame>
+	<img src="/assets/robot_panel_dark.png" alt="Cline's relationship to local and remote assets" />
+</Frame>
+
+### Data Privacy Commitment
+
+Cline implements a strict zero data retention policy, meaning your intellectual property never leaves your secure environment. The extension does not collect, store, or transmit your code to any central servers. This approach significantly reduces potential attack vectors that might otherwise be introduced through data transmission to third-party systems. Telemetry collection is optional and requires explicit consent.
+
+### Cloud Provider Integration
+
+Enterprise teams can access cutting-edge AI models through their existing cloud deployments. Cline supports seamless integration with:
+
+-   AWS Bedrock
+-   Google Cloud Vertex AI
+-   Microsoft Azure
+
+These integrations utilize your organization's existing security credentials, including native IAM role assumption for AWS. This ensures that all AI processing occurs within your corporate cloud environment, maintaining compliance with your established security protocols.
+
+### Open-Source Transparency
+
+Cline's codebase is completely open-source, allowing for comprehensive security auditing by your internal teams. This transparency enables security professionals to verify exactly how the extension functions and confirm that it adheres to your organization's security requirements. Organizations can review the code to ensure it aligns with their security policies before deployment.
+
+### Controlled Modifications
+
+The extension implements safeguards against unauthorized changes to your codebase. Cline requires explicit user approval for all file modifications and terminal commands, preventing accidental or unwanted alterations. This approval-based workflow maintains the integrity of your projects while still providing AI assistance.
+
+### Enterprise Deployment Support
+
+For organizations with strict security review processes, Cline provides comprehensive documentation including detailed deployment diagrams, sequence diagrams illustrating all data flows, and complete security posture documentation. These materials facilitate thorough security reviews and help demonstrate compliance with enterprise data handling standards and regulations.
+
+### Access Control
+
+Enterprise editions of Cline (planned for Q2 2025) will include centralized administration features that allow organizations to:
+
+-   Manage user access with customizable permission levels
+-   Provision accounts with corporate credentials
+-   Immediately revoke access when needed
+-   Control which AI providers and LLM endpoints can be used
+-   Deploy standardized settings across the organization
+-   Prevent unauthorized use of personal API keys
+
+### Compliance and Governance
+
+Cline's architecture supports compliance with data sovereignty requirements and enterprise data handling regulations. The planned Enterprise Complete edition will further enhance governance with detailed audit logging, compliance reporting, and automated policy enforcement mechanisms.
+
+By combining client-side processing, direct cloud provider integration, and transparent operations, Cline offers enterprise teams a secure way to leverage AI assistance while maintaining strict control over their sensitive code and data.

docs/mcp/adding-mcp-servers-from-github.mdx

@@ -0,0 +1,69 @@
+---
+title: "Adding MCP Servers from GitHub"
+---
+
+This guide provides a step-by-step walkthrough of how to use Cline to build an existing MCP server from a GitHub repository.
+
+## **Finding an MCP Server**
+
+There are multiple places online to find MCP servers:
+
+-   **Cline can automatically add MCP servers to its list, which you can then edit.** Cline can clone repositories directly from GitHub and build the servers for you.
+-   **GitHub:** Two of the most common places to find MCP servers on GitHub include:
+    -   [Official MCP servers repository](https://github.com/modelcontextprotocol/servers)
+    -   [Awesome-MCP servers repository](https://github.com/punkpeye/awesome-mcp-servers)
+-   **Online directories:** Several websites list MCP servers including:
+
+    -   [mcpservers.org](https://mcpservers.org/)
+    -   [mcp.so](https://mcp.so/)
+    -   [glama.ai/mcp/servers](https://glama.ai/mcp/servers)
+
+    These directories allow users to sort the servers by various criteria such as downloads, date, stars, and use case. Each entry provides information such as features, tools, and configuration instructions.
+
+-   **PulseMCP:** This website has a blog post discussing how AI could use MCP servers to make websites obsolete. PulseMCP also includes an FAQ section about MCP servers: [https://www.pulsemcp.com/](https://www.pulsemcp.com/)
+
+## **Building with Cline**
+
+1. **Initiate the Process:** Provide Cline with the following information:
+    - **GitHub Repository URL:** The URL of the server's repository.
+    - **README.md Contents:** This is optional but helpful for Cline to understand the server's purpose and configuration. You can copy the README.md file from the GitHub repository.
+2. **Example Interaction with Cline:**
+
+    ```
+    User: "Cline, I want to add the MCP server for Brave browser control. Here's the GitHub link: @https://github.com/modelcontextprotocol/servers/tree/main/src/brave-search Can you add it?"
+
+    Cline: "OK. Cloning the repository to the MCP directory. It needs to be built because it has a 'package.json' file. Should I run 'npm run build'?"
+
+    User: "Yes, build it."
+
+    Cline: "Build complete. This server needs a browser path. Where's your Brave browser executable?"
+
+    User: "It's in '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser'."
+
+    Cline: "OK. I've updated the server config with that path and added it to 'cline_mcp_settings.json'. Anything else?"
+
+    User: "No, that's all. Let's test it."
+
+    Cline: "Great! Starting the MCP Inspector to test the server connection. After that, we can try controlling the browser from Cline."
+    ```
+
+3. **Cline's Actions:** Based on your instructions, Cline will perform the following:
+    - **Repository Cloning:** Cline will clone the repository to your local machine, usually in the directory specified in your configuration.
+    - **Tweaking:** You can guide Cline to modify the server's configuration. For instance:
+        - **User:** "This server requires an API key. Can you find where it should be added?"
+        - Cline may automatically update the `cline_mcp_settings.json` file or other relevant files based on your instructions.
+    - **Building the Server:** Cline will run the appropriate build command for the server, which is commonly `npm run build`.
+    - **Adding Server to Settings:** Cline will add the server's configuration to the `cline_mcp_settings.json` file.
+
+## **Testing and Troubleshooting**
+
+1. **Test the Server:** Once Cline finishes the build process, test the server to make sure it works as expected. Cline can assist you if you encounter any problems.
+2. **MCP Inspector:** You can use the MCP Inspector to test the server's connection and functionality.
+
+## **Best Practices**
+
+-   **Understand the Basics:** While Cline simplifies the process, it's beneficial to have a basic understanding of the server's code, the MCP protocol ([learn more](/mcp/mcp-overview)), and how to configure the server. This allows for more effective troubleshooting and customization.
+-   **Clear Instructions:** Provide clear and specific instructions to Cline throughout the process.
+-   **Testing:** Thoroughly test the server after installation and configuration to ensure it functions correctly.
+-   **Version Control:** Use a version control system (like Git) to track changes to the server's code.
+-   **Stay Updated:** Keep your MCP servers updated to benefit from the latest features and security patches.

docs/mcp/configuring-mcp-servers.mdx

@@ -0,0 +1,164 @@
+---
+title: "Configuring MCP Servers"
+---
+
+## Global MCP Server Inclusion Mode
+
+Utilizing MCP servers will increase your token usage. Cline offers the ability to restrict or disable MCP server functionality as desired.
+
+1. Click the "MCP Servers" icon in the top navigation bar of the Cline extension.
+2. Select the "Installed" tab, and then Click the "Advanced MCP Settings" link at the bottom of that pane.
+3. Cline will open a new settings window. find `Cline>Mcp:Mode` and make your selection from the dropdown menu.
+
+<Frame>
+	<img src="/assets/robot_panel_dark.png" alt="MCP settings edit" />
+</Frame>
+
+## Managing Individual MCP Servers
+
+Each MCP server has its own configuration panel where you can modify settings, manage tools, and control its operation. To access these settings:
+
+1. Click the "MCP Servers" icon in the top navigation bar of the Cline extension.
+2. Locate the MCP server you want to manage in the list, and open it by clicking on its name.
+
+<Frame>
+	<img src="/assets/robot_panel_dark.png" alt="MCP settings individual" />
+</Frame>
+
+### Deleting a Server
+
+1. Click the Trash icon next to the MCP server you would like to delete, or the red Delete Server button at the bottom of the MCP server config box.
+
+**NOTE:** There is no delete confirmation dialog box
+
+### Restarting a Server
+
+1. Click the Restart button next to the MCP server you would like to restart, or the gray Restart Server button at the bottom of the MCP server config box.
+
+### Enabling or Disabling a Server
+
+1. Click the toggle switch next to the MCP server to enable/disable servers individually.
+
+### Network Timeout
+
+To set the maximum time to wait for a response after a tool call to the MCP server:
+
+1. Click the `Network Timeout` dropdown at the bottom of the individual MCP server's config box and change the time. Default is 1 minute but it can be set between 30 seconds and 1 hour.
+
+<Frame>
+	<img src="/assets/robot_panel_dark.png" alt="Network Timeout pulldown" />
+</Frame>
+
+## Editing MCP Settings Files
+
+Settings for all installed MCP servers are located in the `cline_mcp_settings.json` file:
+
+1. Click the MCP Servers icon at the top navigation bar of the Cline pane.
+2. Select the "Installed" tab.
+3. Click the "Configure MCP Servers" button at the bottom of the pane.
+
+The file uses a JSON format with a `mcpServers` object containing named server configurations:
+
+```json
+{
+	"mcpServers": {
+		"server1": {
+			"command": "python",
+			"args": ["/path/to/server.py"],
+			"env": {
+				"API_KEY": "your_api_key"
+			},
+			"alwaysAllow": ["tool1", "tool2"],
+			"disabled": false
+		}
+	}
+}
+```
+
+_Example of MCP Server config in Cline (STDIO Transport)_
+
+---
+
+## Understanding Transport Types
+
+MCP supports two transport types for server communication:
+
+### STDIO Transport
+
+Used for local servers running on your machine:
+
+-   Communicates via standard input/output streams
+-   Lower latency (no network overhead)
+-   Better security (no network exposure)
+-   Simpler setup (no HTTP server needed)
+-   Runs as a child process on your machine
+
+For more in-depth information about how STDIO transport works, see [MCP Transport Mechanisms](/mcp/mcp-transport-mechanisms).
+
+STDIO configuration example:
+
+```json
+{
+	"mcpServers": {
+		"local-server": {
+			"command": "node",
+			"args": ["/path/to/server.js"],
+			"env": {
+				"API_KEY": "your_api_key"
+			},
+			"alwaysAllow": ["tool1", "tool2"],
+			"disabled": false
+		}
+	}
+}
+```
+
+### SSE Transport
+
+Used for remote servers accessed over HTTP/HTTPS:
+
+-   Communicates via Server-Sent Events protocol
+-   Can be hosted on a different machine
+-   Supports multiple client connections
+-   Requires network access
+-   Allows centralized deployment and management
+
+For more in-depth information about how SSE transport works, see [MCP Transport Mechanisms](/mcp/mcp-transport-mechanisms).
+
+SSE configuration example:
+
+```json
+{
+	"mcpServers": {
+		"remote-server": {
+			"url": "https://your-server-url.com/mcp",
+			"headers": {
+				"Authorization": "Bearer your-token"
+			},
+			"alwaysAllow": ["tool3"],
+			"disabled": false
+		}
+	}
+}
+```
+
+---
+
+## Using MCP Tools in Your Workflow
+
+After configuring an MCP server, Cline will automatically detect available tools and resources. To use them:
+
+1. Type your request in Cline's conversation window
+2. Cline will identify when an MCP tool can help with your task
+3. Approve the tool use when prompted (or use auto-approval)
+
+Example: "Analyze the performance of my API" might use an MCP tool that tests API endpoints.
+
+## Troubleshooting MCP Servers
+
+Common issues and solutions:
+
+-   **Server Not Responding:** Check if the server process is running and verify network connectivity
+-   **Permission Errors:** Ensure proper API keys and credentials are configured in your `mcp_settings.json` file
+-   **Tool Not Available:** Confirm the server is properly implementing the tool and it's not disabled in settings
+-   **Slow Performance:** Try adjusting the network timeout value for the specific MCP server

docs/mcp/connecting-to-a-remote-server.mdx

@@ -0,0 +1,132 @@
+---
+title: "Connecting to a Remote Server"
+description: "The Model Context Protocol (MCP) allows Cline to communicate with external servers that provide additional tools and resources to extend its capabilities. This guide explains how to add and connect to remote MCP servers through the MCP Servers interface."
+---
+
+## Adding and Managing Remote MCP Servers
+
+### Accessing the MCP Servers Interface
+
+To access the MCP Servers interface in Cline:
+
+1. Click on the Cline icon in the VSCode sidebar
+2. Open the menu (⋮) in the top right corner of the Cline panel
+3. Select "MCP Servers" from the dropdown menu
+
+### Understanding the MCP Servers Interface
+
+The MCP Servers interface is divided into three main tabs:
+
+-   **Marketplace**: Discover and install pre-configured MCP servers (if enabled)
+-   **Remote Servers**: Connect to existing MCP servers via URL endpoints
+-   **Installed**: Manage your connected MCP servers
+
+### Adding a Remote MCP Server
+
+The "Remote Servers" tab allows you to connect to any MCP server that's accessible via a URL endpoint:
+
+1. Click on the "Remote Servers" tab in the MCP Servers interface
+2. Fill in the required information:
+    - **Server Name**: Provide a unique, descriptive name for the server
+    - **Server URL**: Enter the complete URL endpoint of the MCP server (e.g., `https://example.com/mcp-sse`)
+3. Click "Add Server" to initiate the connection
+4. Cline will attempt to connect to the server and display the connection status
+
+> **Note**: When connecting to a remote server, ensure you trust the source, as MCP servers can execute code in your environment.
+
+### Remote Server Discovery
+
+If you're looking for MCP servers to connect to, several third-party marketplaces provide directories of available servers with various capabilities.
+
+> **Warning**: The following third-party marketplaces are listed for informational purposes only. Cline does not endorse, verify, or take responsibility for any servers listed on these marketplaces. These servers are cloud-hosted services that process your requests and may have access to data you share with them. Always review privacy policies and terms of use before connecting to third-party services.
+
+#### Composio MCP Integration
+
+[Composio's MCP Marketplace](https://mcp.composio.dev/) provides access to a wide range of third-party servers that support the Model Context Protocol (MCP). These servers expose APIs for services like GitHub, Notion, Slack, and others. Each server includes configuration instructions and built-in authentication support (e.g. OAuth or API keys). To connect, locate the desired service in the marketplace and follow the integration steps provided there.
+
+#### Connecting via Smithery
+
+Smithery is a third-party MCP server marketplace that allows users to discover and connect to a variety of Model Context Protocol (MCP) servers. If you're using an MCP-compatible client (such as Cursor, Claude Desktop, or Cline), you can browse available servers and integrate them directly into your workflow.
+
+To explore available options, visit the Smithery marketplace: [https://smithery.ai](https://smithery.ai)
+
+Please note: Smithery is maintained independently and is not affiliated with our project. Use at your own discretion.
+
+### Managing Installed MCP Servers
+
+Once added, your MCP servers appear in the "Installed" tab where you can:
+
+#### View Server Status
+
+Each server displays its current status:
+
+-   **Green dot**: Connected and ready to use
+-   **Yellow dot**: In the process of connecting
+-   **Red dot**: Disconnected or experiencing errors
+
+#### Configure Server Settings
+
+Click on a server to expand its settings panel:
+
+1. **Tools & Resources**:
+    - View all available tools and resources from the server
+    - Configure auto-approval settings for tools (if enabled)
+2. **Request Timeout**:
+    - Set how long Cline should wait for server responses
+    - Options range from 30 seconds to 1 hour
+3. **Server Management**:
+    - **Restart Server**: Reconnect if the server becomes unresponsive
+    - **Delete Server**: Remove the server from your configuration
+
+#### Enable/Disable Servers
+
+Toggle the switch next to each server to enable or disable it:
+
+-   **Enabled**: Cline can use the server's tools and resources
+-   **Disabled**: The server remains in your configuration but is not active
+
+### Troubleshooting Connection Issues
+
+If a server fails to connect:
+
+1. An error message will be displayed with details about the failure
+2. Check that the server URL is correct and the server is running
+3. Use the "Restart Server" button to attempt reconnection
+4. If problems persist, you can delete the server and try adding it again
+
+### Advanced Configuration
+
+For advanced users, Cline stores MCP server configurations in a JSON file that can be modified:
+
+1. In the "Installed" tab, click "Configure MCP Servers" to access the settings file
+2. The configuration for each server follows this format:
+
+```json
+{
+	"mcpServers": {
+		"exampleServer": {
+			"url": "https://example.com/mcp-sse",
+			"disabled": false,
+			"autoApprove": ["tool1", "tool2"],
+			"timeout": 30
+		}
+	}
+}
+```
+
+Key configuration options:
+
+-   **url**: The endpoint URL (for remote servers)
+-   **disabled**: Whether the server is currently enabled (true/false)
+-   **autoApprove**: List of tool names that don't require confirmation
+-   **timeout**: Maximum time in seconds to wait for server responses
+
+For additional MCP settings, click the "Advanced MCP Settings" link to access VSCode settings.
+
+### Using MCP Server Tools
+
+Once connected, Cline can use the tools and resources provided by the MCP server. When Cline suggests using an MCP tool:
+
+1. A tool approval prompt will appear (unless auto-approved)
+2. Review the tool details and parameters before approving
+3. The tool will execute and return results to Cline

docs/mcp/mcp-marketplace.mdx

@@ -0,0 +1,199 @@
+---
+title: "MCP Made Easy"
+description: "Learn how to use the MCP Marketplace to discover, install, and configure MCP servers that enhance Cline's capabilities with additional tools and resources."
+---
+
+## What's an MCP Server?
+
+MCP servers are specialized extensions that enhance Cline's capabilities. They enable Cline to perform additional tasks like fetching web pages, processing images, accessing APIs, and much more.
+
+## MCP Marketplace Walkthrough
+
+The MCP Marketplace provides a one-click installation experience for hundreds of MCP servers across various categories.
+
+### 1. Access the Marketplace
+
+-   In Cline, click the "Extensions" button (square icon) in the top toolbar
+-   The MCP marketplace will open, showing available servers by category
+
+### 2. Browse and Select a Server
+
+-   Browse servers by category (Search, File-systems, Browser-automation, Research-data, etc.)
+-   Click on a server to see details about its capabilities and requirements
+
+### 3. Install and Configure
+
+-   Click the install button for your chosen server
+-   If the server requires an API key (most do), Cline will guide you through:
+    -   Where to get the API key
+    -   How to enter it securely
+-   The server will be added to your MCP settings automatically
+
+### 4. Verify Installation
+
+-   Cline will show confirmation when installation is complete
+-   Check the server status in Cline's MCP settings UI
+
+### 5. Using Your New Server
+
+-   After successful installation, Cline will automatically integrate the server's capabilities
+-   You'll see new tools and resources available in Cline's system prompt
+-   Simply ask Cline to use the capabilities of your new server
+-   Example: "Search the web for recent React updates using Perplexity"
+
+**Corporate Users:** If you're using Cline in a corporate environment, ensure you have permission to install third-party MCP servers according to your organization's security policies.
+
+## What Happens Behind the Scenes
+
+When you install an MCP server, several things happen automatically:
+
+### 1. Installation Process
+
+-   The server code is cloned/installed to `/Users/<username>/Documents/Cline/MCP/`
+-   Dependencies are installed
+-   The server is built (TypeScript/JavaScript compilation or Python package installation)
+
+### 2. Configuration
+
+-   The MCP settings file is updated with your server configuration
+-   This file is located at: `/Users/<username>/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`
+-   Environment variables (like API keys) are securely stored
+-   The server path is registered
+
+### 3. Server Launch
+
+-   Cline detects the configuration change
+-   Cline launches your server as a separate process
+-   Communication is established via stdio or HTTP
+
+### 4. Integration with Cline
+
+-   Your server's capabilities are added to Cline's system prompt
+-   Tools become available via `use_mcp_tool` commands
+-   Resources become available via `access_mcp_resource` commands
+-   Cline can now use these capabilities when prompted by the user
+
+## Troubleshooting
+
+### System Requirements
+
+Make sure your system meets these requirements:
+
+-   **Node.js 18.x or newer**
+    -   Check by running: `node --version`
+    -   Install from: https://nodejs.org/
+    -   Required for JavaScript/TypeScript implementations
+-   **Python 3.10 or newer**
+    -   Check by running: `python --version`
+    -   Install from: https://python.org/
+    -   Note: Some specialized implementations may require Python 3.11+
+-   **UV Package Manager**
+    -   Modern Python package manager for dependency isolation
+    -   Install using:
+        ```bash
+        curl -LsSf https://astral.sh/uv/install.sh | sh
+        ```
+        Or: `pip install uv`
+    -   Verify with: `uv --version`
+
+If any of these commands fail or show older versions, please install/update before continuing!
+
+### Common Installation Issues
+
+-   Ensure your internet connection is stable
+-   Check that you have the necessary permissions to install new software
+-   Verify that the API key was entered correctly (if required)
+-   Check the server status in the MCP settings UI for any error messages
+
+### How to Remove an MCP Server
+
+To completely remove a faulty MCP server:
+
+1. Open the MCP settings file: `/Users/<username>/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`
+2. Delete the entire entry for your server from the `mcpServers` object
+3. Save the file
+4. Restart Cline
+
+### I'm Still Getting an Error
+
+If you're getting an error when using an MCP server, you can try the following:
+
+-   Check the MCP settings file for errors
+-   Use a Claude Sonnet model for installation
+-   Verify that paths to your server's files are correct
+-   Ensure all required environment variables are set
+-   Check if another process is using the same port (for HTTP-based servers)
+-   Try removing and reinstalling the server (remove from both the `cline_mcp_settings.json` file and the `/Users/<username>/Documents/Cline/MCP/` directory)
+-   Use a terminal and run the command with its arguments directly. This will allow you to see the same errors that Cline is seeing
+
+## MCP Server Rules
+
+Cline is already aware of your active MCP servers and what they are for, but when you have a lot of MCP servers enabled, it can be useful to define when to use each server.
+
+Utilize a `.clinerules` file or custom instructions to support intelligent MCP server activation through keyword-based triggers, making Cline's tool selection more intuitive and context-aware.
+
+### How MCP Rules Work
+
+MCP Rules group your connected MCP servers into functional categories and define trigger keywords that activate them automatically when detected in your conversations with Cline.
+
+```json
+{
+	"mcpRules": {
+		"webInteraction": {
+			"servers": ["firecrawl-mcp-server", "fetch-mcp"],
+			"triggers": ["web", "scrape", "browse", "website"],
+			"description": "Tools for web browsing and scraping"
+		}
+	}
+}
+```
+
+### Configuration Structure
+
+1. **Categories**: Group related servers (e.g., "webInteraction", "mediaAndDesign")
+2. **Servers**: List server names in each category
+3. **Triggers**: Keywords that activate these servers
+4. **Description**: Human-readable category explanation
+
+### Benefits of MCP Rules
+
+-   **Contextual Tool Selection**: Cline selects appropriate tools based on conversation context
+-   **Reduced Friction**: No need to manually specify which tool to use
+-   **Organized Capabilities**: Logically group related tools and servers
+-   **Prioritization**: Handle ambiguous cases with explicit priority ordering
+
+### Example Usage
+
+When you write "Can you scrape this website?", Cline detects "scrape" and "website" as triggers, automatically selecting web-related MCP servers.
+
+For finance tasks like "What's Apple's stock price?", keywords like "stock" and "price" trigger finance-related servers.
+
+### Quick Start Template
+
+```json
+{
+	"mcpRules": {
+		"category1": {
+			"servers": ["server-name-1", "server-name-2"],
+			"triggers": ["keyword1", "keyword2", "phrase1", "phrase2"],
+			"description": "Description of what these tools do"
+		},
+		"category2": {
+			"servers": ["server-name-3"],
+			"triggers": ["keyword3", "keyword4", "phrase3"],
+			"description": "Description of what these tools do"
+		},
+		"category3": {
+			"servers": ["server-name-4", "server-name-5"],
+			"triggers": ["keyword5", "keyword6", "phrase4"],
+			"description": "Description of what these tools do"
+		}
+	},
+	"defaultBehavior": {
+		"priorityOrder": ["category1", "category2", "category3"],
+		"fallbackBehavior": "Ask user which tool would be most appropriate"
+	}
+}
+```
+
+Add this to your `.clinerules` file or to your custom instructions to make Cline's MCP server selection more intuitive and context-aware.

docs/mcp/mcp-overview.mdx

@@ -0,0 +1,107 @@
+---
+title: "MCP Overview"
+description: "Learn about Model Context Protocol (MCP) servers, their capabilities, and how Cline can help build and use them. MCP standardizes how applications provide context to LLMs, acting like a USB-C port for AI applications."
+---
+
+## Quick Links
+
+-   [Building MCP Servers from GitHub](/mcp/adding-mcp-servers-from-github)
+-   [Building Custom MCP Servers from Scratch](/mcp/mcp-server-development-protocol)
+
+## Overview
+
+Model Context Protocol is an open protocol that standardizes how applications provide context to LLMs. Think of MCP like a USB-C port for AI applications; it provides a standardized way to connect AI models to different data sources and tools. MCP servers act as intermediaries between large language models (LLMs), such as Claude, and external tools or data sources. They are small programs that expose functionalities to LLMs, enabling them to interact with the outside world through the MCP. An MCP server is essentially like an API that an LLM can use.
+
+<Frame>
+	<img
+		src="/assets/robot_panel_dark.png"
+		alt="MCP diagram showing how MCP servers connect LLMs to external tools and data sources"
+	/>
+</Frame>
+
+## Key Concepts
+
+MCP servers define a set of "**tools,**" which are functions the LLM can execute. These tools offer a wide range of capabilities.
+
+**Here's how MCP works:**
+
+-   **MCP hosts** discover the capabilities of connected servers and load their tools, prompts, and resources.
+-   **Resources** provide consistent access to read-only data, akin to file paths or database queries.
+-   **Security** is ensured as servers isolate credentials and sensitive data. Interactions require explicit user approval.
+
+## Use Cases
+
+The potential of MCP servers is vast. They can be used for a variety of purposes.
+
+**Here are some concrete examples of how MCP servers can be used:**
+
+-   **Web Services and API Integration:**
+    -   Monitor GitHub repositories for new issues
+    -   Post updates to Twitter based on specific triggers
+    -   Retrieve real-time weather data for location-based services
+-   **Browser Automation:**
+    -   Automate web application testing
+    -   Scrape e-commerce sites for price comparisons
+    -   Generate screenshots for website monitoring
+-   **Database Queries:**
+    -   Generate weekly sales reports
+    -   Analyze customer behavior patterns
+    -   Create real-time dashboards for business metrics
+-   **Project and Task Management:**
+    -   Automate Jira ticket creation based on code commits
+    -   Generate weekly progress reports
+    -   Create task dependencies based on project requirements
+-   **Codebase Documentation:**
+    -   Generate API documentation from code comments
+    -   Create architecture diagrams from code structure
+    -   Maintain up-to-date README files
+
+## Getting Started
+
+Cline does not come with any pre-installed MCP servers. You'll need to find and install them separately.
+
+**Choose the right approach for your needs:**
+
+-   **Community Repositories:** Check for community-maintained lists of MCP servers on GitHub. See [Adding MCP Servers from Github](/mcp/adding-mcp-servers-from-github)
+-   **Cline Marketplace:** Install one from Cline's [MCP Marketplace](/mcp/mcp-marketplace)
+-   **Ask Cline:** You can ask Cline to help you find or create MCP servers
+-   **Build Your Own:** Create custom MCP servers using the [MCP SDK](https://github.com/modelcontextprotocol/)
+-   **Customize Existing Servers:** Modify existing servers to fit your specific requirements
+
+## Integration with Cline
+
+Cline simplifies the building and use of MCP servers through its AI capabilities.
+
+### Building MCP Servers
+
+-   **Natural language understanding:** Instruct Cline in natural language to build an MCP server by describing its functionalities. Cline will interpret your instructions and generate the necessary code.
+-   **Cloning and building servers:** Cline can clone existing MCP server repositories from GitHub and build them automatically.
+-   **Configuration and dependency management:** Cline handles configuration files, environment variables, and dependencies.
+-   **Troubleshooting and debugging:** Cline helps identify and resolve errors during development.
+
+### Using MCP Servers
+
+-   **Tool execution:** Cline seamlessly integrates with MCP servers, allowing you to execute their defined tools.
+-   **Context-aware interactions:** Cline can intelligently suggest using relevant tools based on conversation context.
+-   **Dynamic integrations:** Combine multiple MCP server capabilities for complex tasks. For example, Cline could use a GitHub server to get data and a Notion server to create a formatted report.
+
+## Security Considerations
+
+When working with MCP servers, it's important to follow security best practices:
+
+-   **Authentication:** Always use secure authentication methods for API access
+-   **Environment Variables:** Store sensitive information in environment variables
+-   **Access Control:** Limit server access to authorized users only
+-   **Data Validation:** Validate all inputs to prevent injection attacks
+-   **Logging:** Implement secure logging practices without exposing sensitive data
+
+## Resources
+
+There are various resources available for finding and learning about MCP servers.
+
+**Here are some links to resources for finding and learning about MCP servers:**
+
+-   **GitHub Repositories:** [https://github.com/modelcontextprotocol/servers](https://github.com/modelcontextprotocol/servers) and [https://github.com/punkpeye/awesome-mcp-servers](https://github.com/punkpeye/awesome-mcp-servers)
+-   **Online Directories:** [https://mcpservers.org/](https://mcpservers.org/), [https://mcp.so/](https://mcp.so/), and [https://glama.ai/mcp/servers](https://glama.ai/mcp/servers)
+-   **PulseMCP:** [https://www.pulsemcp.com/](https://www.pulsemcp.com/)
+-   **YouTube Tutorial (AI-Driven Coder):** A video guide for building and using MCP servers: [https://www.youtube.com/watch?v=b5pqTNiuuJg](https://www.youtube.com/watch?v=b5pqTNiuuJg)

docs/mcp/mcp-server-development-protocol.mdx

@@ -0,0 +1,699 @@
+---
+title: "MCP Server Development Protocol"
+description: "This protocol is designed to streamline the development process of building MCP servers with Cline."
+---
+
+> 🚀 **Build and share your MCP servers with the world.** Once you've created a great MCP server, submit it to the [Cline MCP Marketplace](https://github.com/cline/mcp-marketplace) to make it discoverable and one-click installable by thousands of developers.
+
+## What Are MCP Servers?
+
+Model Context Protocol (MCP) servers extend AI assistants like Cline by giving them the ability to:
+
+-   Access external APIs and services
+-   Retrieve real-time data
+-   Control applications and local systems
+-   Perform actions beyond what text prompts alone can achieve
+
+Without MCP, AI assistants are powerful but isolated. With MCP, they gain the ability to interact with virtually any digital system.
+
+## The Development Protocol
+
+The heart of effective MCP server development is following a structured protocol. This protocol is implemented through a `.clinerules` file that lives at the **root** of your MCP working directory (/Users/your-name/Documents/Cline/MCP).
+
+### Using `.clinerules` Files
+
+A `.clinerules` file is a special configuration that Cline reads automatically when working in the directory where it's placed. These files:
+
+-   Configure Cline's behavior and enforce best practices
+-   Switch Cline into a specialized MCP development mode
+-   Provide a step-by-step protocol for building servers
+-   Implement safety measures like preventing premature completion
+-   Guide you through planning, implementation, and testing phases
+
+Here's the complete MCP Server Development Protocol that should be placed in your `.clinerules` file:
+
+````markdown
+# MCP Server Development Protocol
+
+⚠️ CRITICAL: DO NOT USE attempt_completion BEFORE TESTING ⚠️
+
+## Step 1: Planning (PLAN MODE)
+
+-   What problem does this tool solve?
+-   What API/service will it use?
+-   What are the authentication requirements?
+    □ Standard API key
+    □ OAuth (requires separate setup script)
+    □ Other credentials
+
+## Step 2: Implementation (ACT MODE)
+
+1. Bootstrap
+
+    - For web services, JavaScript integration, or Node.js environments:
+        ```bash
+        npx @modelcontextprotocol/create-server my-server
+        cd my-server
+        npm install
+        ```
+    - For data science, ML workflows, or Python environments:
+        ```bash
+        pip install mcp
+        # Or with uv (recommended)
+        uv add "mcp[cli]"
+        ```
+
+2. Core Implementation
+
+    - Use MCP SDK
+    - Implement comprehensive logging
+        - TypeScript (for web/JS projects):
+            ```typescript
+            console.error("[Setup] Initializing server...")
+            console.error("[API] Request to endpoint:", endpoint)
+            console.error("[Error] Failed with:", error)
+            ```
+        - Python (for data science/ML projects):
+            ```python
+            import logging
+            logging.error('[Setup] Initializing server...')
+            logging.error(f'[API] Request to endpoint: {endpoint}')
+            logging.error(f'[Error] Failed with: {str(error)}')
+            ```
+    - Add type definitions
+    - Handle errors with context
+    - Implement rate limiting if needed
+
+3. Configuration
+
+    - Get credentials from user if needed
+    - Add to MCP settings:
+
+        - For TypeScript projects:
+            ```json
+            {
+            	"mcpServers": {
+            		"my-server": {
+            			"command": "node",
+            			"args": ["path/to/build/index.js"],
+            			"env": {
+            				"API_KEY": "key"
+            			},
+            			"disabled": false,
+            			"autoApprove": []
+            		}
+            	}
+            }
+            ```
+        - For Python projects:
+
+            ```bash
+            # Directly with command line
+            mcp install server.py -v API_KEY=key
+
+            # Or in settings.json
+            {
+              "mcpServers": {
+                "my-server": {
+                  "command": "python",
+                  "args": ["server.py"],
+                  "env": {
+                    "API_KEY": "key"
+                  },
+                  "disabled": false,
+                  "autoApprove": []
+                }
+              }
+            }
+            ```
+
+## Step 3: Testing (BLOCKER ⛔️)
+
+<thinking>
+BEFORE using attempt_completion, I MUST verify:
+□ Have I tested EVERY tool?
+□ Have I confirmed success from the user for each test?
+□ Have I documented the test results?
+
+If ANY answer is "no", I MUST NOT use attempt_completion.
+</thinking>
+
+1. Test Each Tool (REQUIRED)
+   □ Test each tool with valid inputs
+   □ Verify output format is correct
+   ⚠️ DO NOT PROCEED UNTIL ALL TOOLS TESTED
+
+## Step 4: Completion
+
+❗ STOP AND VERIFY:
+□ Every tool has been tested with valid inputs
+□ Output format is correct for each tool
+
+Only after ALL tools have been tested can attempt_completion be used.
+
+## Key Requirements
+
+-   ✓ Must use MCP SDK
+-   ✓ Must have comprehensive logging
+-   ✓ Must test each tool individually
+-   ✓ Must handle errors gracefully
+-   ⛔️ NEVER skip testing before completion
+````
+
+When this `.clinerules` file is present in your working directory, Cline will:
+
+1. Start in **PLAN MODE** to design your server before implementation
+2. Enforce proper implementation patterns in **ACT MODE**
+3. Require testing of all tools before allowing completion
+4. Guide you through the entire development lifecycle
+
+## Getting Started
+
+Creating an MCP server requires just a few simple steps to get started:
+
+### 1. Create a `.clinerules` file (🚨 IMPORTANT)
+
+First, add a `.clinerules` file to the root of your MCP working directory using the protocol above. This file configures Cline to use the MCP development protocol when working in this folder.
+
+### 2. Start a Chat with a Clear Description
+
+Begin your Cline chat by clearly describing what you want to build. Be specific about:
+
+-   The purpose of your MCP server
+-   Which API or service you want to integrate with
+-   Any specific tools or features you need
+
+For example:
+
+```plaintext
+I want to build an MCP server for the AlphaAdvantage financial API.
+It should allow me to get real-time stock data, perform technical
+analysis, and retrieve company financial information.
+```
+
+### 3. Work Through the Protocol
+
+Cline will automatically start in PLAN MODE, guiding you through the planning process:
+
+-   Discussing the problem scope
+-   Reviewing API documentation
+-   Planning authentication methods
+-   Designing tool interfaces
+
+When ready, switch to ACT MODE using the toggle at the bottom of the chat to begin implementation.
+
+### 4. Provide API Documentation Early
+
+One of the most effective ways to help Cline build your MCP server is to share official API documentation right at the start:
+
+```plaintext
+Here's the API documentation for the service:
+[Paste API documentation here]
+```
+
+Providing comprehensive API details (endpoints, authentication, data structures) significantly improves Cline's ability to implement an effective MCP server.
+
+## Understanding the Two Modes
+
+### PLAN MODE
+
+In this collaborative phase, you work with Cline to design your MCP server:
+
+-   Define the problem scope
+-   Choose appropriate APIs
+-   Plan authentication methods
+-   Design the tool interfaces
+-   Determine data formats
+
+### ACT MODE
+
+Once planning is complete, Cline helps implement the server:
+
+-   Set up the project structure
+-   Write the implementation code
+-   Configure settings
+-   Test each component thoroughly
+-   Finalize documentation
+
+## Case Study: AlphaAdvantage Stock Analysis Server
+
+Let's walk through the development process of our AlphaAdvantage MCP server, which provides stock data analysis and reporting capabilities.
+
+### Planning Phase
+
+<Frame>
+	<img src="/assets/robot_panel_dark.png" alt="Planning phase demonstration" />
+</Frame>
+
+During the planning phase, we:
+
+1. **Defined the problem**: Users need access to financial data, stock analysis, and market insights directly through their AI assistant
+2. **Selected the API**: AlphaAdvantage API for financial market data
+    - Standard API key authentication
+    - Rate limits of 5 requests per minute (free tier)
+    - Various endpoints for different financial data types
+3. **Designed the tools needed**:
+    - Stock overview information (current price, company details)
+    - Technical analysis with indicators (RSI, MACD, etc.)
+    - Fundamental analysis (financial statements, ratios)
+    - Earnings report data
+    - News and sentiment analysis
+4. **Planned data formatting**:
+    - Clean, well-formatted markdown output
+    - Tables for structured data
+    - Visual indicators (↑/↓) for trends
+    - Proper formatting of financial numbers
+
+### Implementation
+
+<Frame>
+	<img src="/assets/robot_panel_dark.png" alt="Building MCP plugin demonstration" />
+</Frame>
+
+We began by bootstrapping the project:
+
+```bash
+npx @modelcontextprotocol/create-server alphaadvantage-mcp
+cd alphaadvantage-mcp
+npm install axios node-cache
+```
+
+Next, we structured our project with:
+
+```plaintext
+src/
+  ├── api/
+  │   └── alphaAdvantageClient.ts  # API client with rate limiting & caching
+  ├── formatters/
+  │   └── markdownFormatter.ts     # Output formatters for clean markdown
+  └── index.ts                     # Main MCP server implementation
+```
+
+#### API Client Implementation
+
+The API client implementation included:
+
+-   **Rate limiting**: Enforcing the 5 requests per minute limit
+-   **Caching**: Reducing API calls with strategic caching
+-   **Error handling**: Robust error detection and reporting
+-   **Typed interfaces**: Clear TypeScript types for all data
+
+Key implementation details:
+
+```typescript
+/**
+ * Manage rate limiting based on free tier (5 calls per minute)
+ */
+private async enforceRateLimit() {
+  if (this.requestsThisMinute >= 5) {
+    console.error("[Rate Limit] Rate limit reached. Waiting for next minute...");
+    return new Promise<void>((resolve) => {
+      const remainingMs = 60 * 1000 - (Date.now() % (60 * 1000));
+      setTimeout(resolve, remainingMs + 100); // Add 100ms buffer
+    });
+  }
+
+  this.requestsThisMinute++;
+  return Promise.resolve();
+}
+```
+
+#### Markdown Formatting
+
+We implemented formatters to display financial data beautifully:
+
+```typescript
+/**
+ * Format company overview into markdown
+ */
+export function formatStockOverview(overviewData: any, quoteData: any): string {
+	// Extract data
+	const overview = overviewData
+	const quote = quoteData["Global Quote"]
+
+	// Calculate price change
+	const currentPrice = parseFloat(quote["05. price"] || "0")
+	const priceChange = parseFloat(quote["09. change"] || "0")
+	const changePercent = parseFloat(quote["10. change percent"]?.replace("%", "") || "0")
+
+	// Format markdown
+	let markdown = `# ${overview.Symbol} (${overview.Name}) - ${formatCurrency(currentPrice)} ${addTrendIndicator(priceChange)}${changePercent > 0 ? "+" : ""}${changePercent.toFixed(2)}%\n\n`
+
+	// Add more details...
+
+	return markdown
+}
+```
+
+#### Tool Implementation
+
+We defined five tools with clear interfaces:
+
+```typescript
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+	console.error("[Setup] Listing available tools")
+
+	return {
+		tools: [
+			{
+				name: "get_stock_overview",
+				description: "Get basic company info and current quote for a stock symbol",
+				inputSchema: {
+					type: "object",
+					properties: {
+						symbol: {
+							type: "string",
+							description: "Stock symbol (e.g., 'AAPL')",
+						},
+						market: {
+							type: "string",
+							description: "Optional market (e.g., 'US')",
+							default: "US",
+						},
+					},
+					required: ["symbol"],
+				},
+			},
+			// Additional tools defined here...
+		],
+	}
+})
+```
+
+Each tool's handler included:
+
+-   Input validation
+-   API client calls with error handling
+-   Markdown formatting of responses
+-   Comprehensive logging
+
+### Testing Phase
+
+This critical phase involved systematically testing each tool:
+
+1. First, we configured the MCP server in the settings:
+
+```json
+{
+	"mcpServers": {
+		"alphaadvantage-mcp": {
+			"command": "node",
+			"args": ["/path/to/alphaadvantage-mcp/build/index.js"],
+			"env": {
+				"ALPHAVANTAGE_API_KEY": "YOUR_API_KEY"
+			},
+			"disabled": false,
+			"autoApprove": []
+		}
+	}
+}
+```
+
+2. Then we tested each tool individually:
+
+-   **get_stock_overview**: Retrieved AAPL stock overview information
+
+    ```markdown
+    # AAPL (Apple Inc) - $241.84 ↑+1.91%
+
+    **Sector:** TECHNOLOGY
+    **Industry:** ELECTRONIC COMPUTERS
+    **Market Cap:** 3.63T
+    **P/E Ratio:** 38.26
+    ...
+    ```
+
+-   **get_technical_analysis**: Obtained price action and RSI data
+
+    ```markdown
+    # Technical Analysis: AAPL
+
+    ## Daily Price Action
+
+    Current Price: $241.84 (↑$4.54, +1.91%)
+
+    ### Recent Daily Prices
+
+    | Date       | Open    | High    | Low     | Close   | Volume |
+    | ---------- | ------- | ------- | ------- | ------- | ------ |
+    | 2025-02-28 | $236.95 | $242.09 | $230.20 | $241.84 | 56.83M |
+
+    ...
+    ```
+
+-   **get_earnings_report**: Retrieved MSFT earnings history and formatted report
+
+    ```markdown
+    # Earnings Report: MSFT (Microsoft Corporation)
+
+    **Sector:** TECHNOLOGY
+    **Industry:** SERVICES-PREPACKAGED SOFTWARE
+    **Current EPS:** $12.43
+
+    ## Recent Quarterly Earnings
+
+    | Quarter    | Date       | EPS Estimate | EPS Actual | Surprise % |
+    | ---------- | ---------- | ------------ | ---------- | ---------- |
+    | 2024-12-31 | 2025-01-29 | $3.11        | $3.23      | ↑4.01%     |
+
+    ...
+    ```
+
+### Challenges and Solutions
+
+During development, we encountered several challenges:
+
+1. **API Rate Limiting**:
+    - **Challenge**: Free tier limited to 5 calls per minute
+    - **Solution**: Implemented queuing, enforced rate limits, and added comprehensive caching
+2. **Data Formatting**:
+    - **Challenge**: Raw API data not user-friendly
+    - **Solution**: Created formatting utilities for consistent display of financial data
+3. **Timeout Issues**:
+    - **Challenge**: Complex tools making multiple API calls could timeout
+    - **Solution**: Suggested breaking complex tools into smaller pieces, optimizing caching
+
+### Lessons Learned
+
+Our AlphaAdvantage implementation taught us several key lessons:
+
+1. **Plan for API Limits**: Understand and design around API rate limits from the beginning
+2. **Cache Strategically**: Identify high-value caching opportunities to improve performance
+3. **Format for Readability**: Invest in good data formatting for improved user experience
+4. **Test Every Path**: Test all tools individually before completion
+5. **Handle API Complexity**: For APIs requiring multiple calls, design tools with simpler scopes
+
+## Core Implementation Best Practices
+
+### Comprehensive Logging
+
+Effective logging is essential for debugging MCP servers:
+
+```typescript
+// Start-up logging
+console.error("[Setup] Initializing AlphaAdvantage MCP server...")
+
+// API request logging
+console.error(`[API] Getting stock overview for ${symbol}`)
+
+// Error handling with context
+console.error(`[Error] Tool execution failed: ${error.message}`)
+
+// Cache operations
+console.error(`[Cache] Using cached data for: ${cacheKey}`)
+```
+
+### Strong Typing
+
+Type definitions prevent errors and improve maintainability:
+
+```typescript
+export interface AlphaAdvantageConfig {
+	apiKey: string
+	cacheTTL?: Partial<typeof DEFAULT_CACHE_TTL>
+	baseURL?: string
+}
+
+/**
+ * Validate that a stock symbol is provided and looks valid
+ */
+function validateSymbol(symbol: unknown): asserts symbol is string {
+	if (typeof symbol !== "string" || symbol.trim() === "") {
+		throw new McpError(ErrorCode.InvalidParams, "A valid stock symbol is required")
+	}
+
+	// Basic symbol validation (letters, numbers, dots)
+	const symbolRegex = /^[A-Za-z0-9.]+$/
+	if (!symbolRegex.test(symbol)) {
+		throw new McpError(ErrorCode.InvalidParams, `Invalid stock symbol: ${symbol}`)
+	}
+}
+```
+
+### Intelligent Caching
+
+Reduce API calls and improve performance:
+
+```typescript
+// Default cache TTL in seconds
+const DEFAULT_CACHE_TTL = {
+	STOCK_OVERVIEW: 60 * 60, // 1 hour
+	TECHNICAL_ANALYSIS: 60 * 30, // 30 minutes
+	FUNDAMENTAL_ANALYSIS: 60 * 60 * 24, // 24 hours
+	EARNINGS_REPORT: 60 * 60 * 24, // 24 hours
+	NEWS: 60 * 15, // 15 minutes
+}
+
+// Check cache first
+const cachedData = this.cache.get<T>(cacheKey)
+if (cachedData) {
+	console.error(`[Cache] Using cached data for: ${cacheKey}`)
+	return cachedData
+}
+
+// Cache successful responses
+this.cache.set(cacheKey, response.data, cacheTTL)
+```
+
+### Graceful Error Handling
+
+Implement robust error handling that maintains a good user experience:
+
+```typescript
+try {
+	switch (request.params.name) {
+		case "get_stock_overview": {
+			// Implementation...
+		}
+
+		// Other cases...
+
+		default:
+			throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`)
+	}
+} catch (error) {
+	console.error(`[Error] Tool execution failed: ${error instanceof Error ? error.message : String(error)}`)
+
+	if (error instanceof McpError) {
+		throw error
+	}
+
+	return {
+		content: [
+			{
+				type: "text",
+				text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+			},
+		],
+		isError: true,
+	}
+}
+```
+
+## MCP Resources
+
+Resources let your MCP servers expose data to Cline without executing code. They're perfect for providing context like files, API responses, or database records that Cline can reference during conversations.
+
+### Adding Resources to Your MCP Server
+
+1. **Define the resources** your server will expose:
+
+```typescript
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+	return {
+		resources: [
+			{
+				uri: "file:///project/readme.md",
+				name: "Project README",
+				mimeType: "text/markdown",
+			},
+		],
+	}
+})
+```
+
+2. **Implement read handlers** to deliver the content:
+
+```typescript
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+	if (request.params.uri === "file:///project/readme.md") {
+		const content = await fs.promises.readFile("/path/to/readme.md", "utf-8")
+		return {
+			contents: [
+				{
+					uri: request.params.uri,
+					mimeType: "text/markdown",
+					text: content,
+				},
+			],
+		}
+	}
+
+	throw new Error("Resource not found")
+})
+```
+
+Resources make your MCP servers more context-aware, allowing Cline to access specific information without requiring you to copy/paste. For more information, refer to the [official documentation](https://modelcontextprotocol.io/docs/concepts/resources).
+
+## Common Challenges and Solutions
+
+### API Authentication Complexities
+
+**Challenge**: APIs often have different authentication methods.
+
+**Solution**:
+
+-   For API keys, use environment variables in the MCP configuration
+-   For OAuth, create a separate script to obtain refresh tokens
+-   Store sensitive tokens securely
+
+```typescript
+// Authenticate using API key from environment
+const API_KEY = process.env.ALPHAVANTAGE_API_KEY
+if (!API_KEY) {
+	console.error("[Error] Missing ALPHAVANTAGE_API_KEY environment variable")
+	process.exit(1)
+}
+
+// Initialize API client
+const apiClient = new AlphaAdvantageClient({
+	apiKey: API_KEY,
+})
+```
+
+### Missing or Limited API Features
+
+**Challenge**: APIs may not provide all the functionality you need.
+
+**Solution**:
+
+-   Implement fallbacks using available endpoints
+-   Create simulated functionality where necessary
+-   Transform API data to match your needs
+
+### API Rate Limiting
+
+**Challenge**: Most APIs have rate limits that can cause failures.
+
+**Solution**:
+
+-   Implement proper rate limiting
+-   Add intelligent caching
+-   Provide graceful degradation
+-   Add transparent errors about rate limits
+
+```typescript
+if (this.requestsThisMinute >= 5) {
+	console.error("[Rate Limit] Rate limit reached. Waiting for next minute...")
+	return new Promise<void>((resolve) => {
+		const remainingMs = 60 * 1000 - (Date.now() % (60 * 1000))
+		setTimeout(resolve, remainingMs + 100) // Add 100ms buffer
+	})
+}
+```
+
+## Additional Resources
+
+-   [MCP Protocol Documentation](https://github.com/modelcontextprotocol/mcp)
+-   [MCP SDK Documentation](https://github.com/modelcontextprotocol/sdk-js)
+-   [MCP Server Examples](https://github.com/modelcontextprotocol/servers)

docs/mcp/mcp-transport-mechanisms.mdx

@@ -0,0 +1,197 @@
+---
+title: "MCP Transport Mechanisms"
+description: "Learn about the two primary transport mechanisms for communication between Cline and MCP servers: Standard Input/Output (STDIO) and Server-Sent Events (SSE). Each has distinct characteristics, advantages, and use cases."
+---
+
+Model Context Protocol (MCP) supports two primary transport mechanisms for communication between Cline and MCP servers: Standard Input/Output (STDIO) and Server-Sent Events (SSE). Each has distinct characteristics, advantages, and use cases.
+
+## STDIO Transport
+
+STDIO transport runs locally on your machine and communicates via standard input/output streams.
+
+### How STDIO Transport Works
+
+1. The client (Cline) spawns an MCP server as a child process
+2. Communication happens through process streams: client writes to server's STDIN, server responds to STDOUT
+3. Each message is delimited by a newline character
+4. Messages are formatted as JSON-RPC 2.0
+
+```plaintext
+Client                    Server
+  |                         |
+  |<---- JSON message ----->| (via STDIN)
+  |                         | (processes request)
+  |<---- JSON message ------| (via STDOUT)
+  |                         |
+```
+
+### STDIO Characteristics
+
+-   **Locality**: Runs on the same machine as Cline
+-   **Performance**: Very low latency and overhead (no network stack involved)
+-   **Simplicity**: Direct process communication without network configuration
+-   **Relationship**: One-to-one relationship between client and server
+-   **Security**: Inherently more secure as no network exposure
+
+### When to Use STDIO
+
+STDIO transport is ideal for:
+
+-   Local integrations and tools running on the same machine
+-   Security-sensitive operations
+-   Low-latency requirements
+-   Single-client scenarios (one Cline instance per server)
+-   Command-line tools or IDE extensions
+
+### STDIO Implementation Example
+
+```typescript
+import { Server } from "@modelcontextprotocol/sdk/server/index.js"
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
+
+const server = new Server({ name: "local-server", version: "1.0.0" })
+// Register tools...
+
+// Use STDIO transport
+const transport = new StdioServerTransport(server)
+transport.listen()
+```
+
+## SSE Transport
+
+Server-Sent Events (SSE) transport runs on a remote server and communicates over HTTP/HTTPS.
+
+### How SSE Transport Works
+
+1. The client (Cline) connects to the server's SSE endpoint via HTTP GET request
+2. This establishes a persistent connection where the server can push events to the client
+3. For client-to-server communication, the client makes HTTP POST requests to a separate endpoint
+4. Communication happens over two channels:
+    - Event Stream (GET): Server-to-client updates
+    - Message Endpoint (POST): Client-to-server requests
+
+```plaintext
+Client                             Server
+  |                                  |
+  |---- HTTP GET /events ----------->| (establish SSE connection)
+  |<---- SSE event stream -----------| (persistent connection)
+  |                                  |
+  |---- HTTP POST /message --------->| (client request)
+  |<---- SSE event with response ----| (server response)
+  |                                  |
+```
+
+### SSE Characteristics
+
+-   **Remote Access**: Can be hosted on a different machine from your Cline instance
+-   **Scalability**: Can handle multiple client connections concurrently
+-   **Protocol**: Works over standard HTTP (no special protocols needed)
+-   **Persistence**: Maintains a persistent connection for server-to-client messages
+-   **Authentication**: Can use standard HTTP authentication mechanisms
+
+### When to Use SSE
+
+SSE transport is better for:
+
+-   Remote access across networks
+-   Multi-client scenarios
+-   Public services
+-   Centralized tools that many users need to access
+-   Integration with web services
+
+### SSE Implementation Example
+
+```typescript
+import { Server } from "@modelcontextprotocol/sdk/server/index.js"
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js"
+import express from "express"
+
+const app = express()
+const server = new Server({ name: "remote-server", version: "1.0.0" })
+// Register tools...
+
+// Use SSE transport
+const transport = new SSEServerTransport(server)
+app.use("/mcp", transport.requestHandler())
+app.listen(3000, () => {
+	console.log("MCP server listening on port 3000")
+})
+```
+
+## Local vs. Hosted: Deployment Aspects
+
+The choice between STDIO and SSE transports directly impacts how you'll deploy and manage your MCP servers.
+
+### STDIO: Local Deployment Model
+
+STDIO servers run locally on the same machine as Cline, which has several important implications:
+
+-   **Installation**: The server executable must be installed on each user's machine
+-   **Distribution**: You need to provide installation packages for different operating systems
+-   **Updates**: Each instance must be updated separately
+-   **Resources**: Uses the local machine's CPU, memory, and disk
+-   **Access Control**: Relies on the local machine's filesystem permissions
+-   **Integration**: Easy integration with local system resources (files, processes)
+-   **Execution**: Starts and stops with Cline (child process lifecycle)
+-   **Dependencies**: Any dependencies must be installed on the user's machine
+
+#### Practical Example
+
+A local file search tool using STDIO would:
+
+-   Run on the user's machine
+-   Have direct access to the local filesystem
+-   Start when needed by Cline
+-   Not require network configuration
+-   Need to be installed alongside Cline or via a package manager
+
+### SSE: Hosted Deployment Model
+
+SSE servers can be deployed to remote servers and accessed over the network:
+
+-   **Installation**: Installed once on a server, accessed by many users
+-   **Distribution**: Single deployment serves multiple clients
+-   **Updates**: Centralized updates affect all users immediately
+-   **Resources**: Uses server resources, not local machine resources
+-   **Access Control**: Managed through authentication and authorization systems
+-   **Integration**: More complex integration with user-specific resources
+-   **Execution**: Runs as an independent service (often continuously)
+-   **Dependencies**: Managed on the server, not on user machines
+
+#### Practical Example
+
+A database query tool using SSE would:
+
+-   Run on a central server
+-   Connect to databases with server-side credentials
+-   Be continuously available for multiple users
+-   Require proper network security configuration
+-   Be deployed using container or cloud technologies
+
+### Hybrid Approaches
+
+Some scenarios benefit from a hybrid approach:
+
+1. **STDIO with Network Access**: A local STDIO server that acts as a proxy to remote services
+2. **SSE with Local Commands**: A remote SSE server that can trigger operations on the client machine through callbacks
+3. **Gateway Pattern**: STDIO servers for local operations that connect to SSE servers for specialized functions
+
+## Choosing Between STDIO and SSE
+
+| Consideration        | STDIO                    | SSE                                 |
+| -------------------- | ------------------------ | ----------------------------------- |
+| **Location**         | Local machine only       | Local or remote                     |
+| **Clients**          | Single client            | Multiple clients                    |
+| **Performance**      | Lower latency            | Higher latency (network overhead)   |
+| **Setup Complexity** | Simpler                  | More complex (requires HTTP server) |
+| **Security**         | Inherently secure        | Requires explicit security measures |
+| **Network Access**   | Not needed               | Required                            |
+| **Scalability**      | Limited to local machine | Can distribute across network       |
+| **Deployment**       | Per-user installation    | Centralized installation            |
+| **Updates**          | Distributed updates      | Centralized updates                 |
+| **Resource Usage**   | Uses client resources    | Uses server resources               |
+| **Dependencies**     | Client-side dependencies | Server-side dependencies            |
+
+## Configuring Transports in Cline
+
+For detailed information on configuring STDIO and SSE transports in Cline, including examples, see [Configuring MCP Servers](/mcp/configuring-mcp-servers).

docs/more-info/telemetry.mdx

@@ -0,0 +1,34 @@
+---
+title: "Telemetry"
+---
+
+### Overview
+
+To help make Cline better for everyone, we collect anonymous usage data that helps us understand how developers are using our open-source AI coding agent. This feedback loop is crucial for improving Cline's capabilities and user experience.
+
+We use PostHog, an open-source analytics platform, for data collection and analysis. Our telemetry implementation is fully transparent - you can review the [source code](https://github.com/cline/cline/blob/main/src/services/telemetry/TelemetryService.ts) to see exactly what we track.
+
+### Tracking Policy
+
+Privacy is our priority. All collected data is anonymized before being sent to PostHog, with no personally identifiable information (PII) included. Your code, prompts, and conversation content always remain private and are never collected.
+
+### What We Track
+
+We collect basic anonymous usage data including:
+
+**Task Interactions:** When tasks start and finish, conversation flow (without content)\
+**Mode and Tool Usage:** Switches between plan/act modes, which tools are being used\
+**Token Usage:** Basic metrics about conversation length to estimate cost (not the actual content of the tokens)\
+**System Context:** OS type and VS Code environment details\
+**UI Activity:** Navigation patterns and feature usage
+
+For complete transparency, you can inspect our [telemetry implementation](https://github.com/cline/cline/blob/main/src/services/telemetry/TelemetryService.ts) to see the exact events we track.
+
+### How to Opt Out
+
+Telemetry in Cline is entirely optional and requires your explicit consent:
+
+-   When you update or install our VS Code extension, you'll see a simple prompt: "Help Improve Cline" with Allow or Deny options
+-   You can change your preference anytime in settings
+
+Cline also respects VS Code's global telemetry settings. If you've disabled telemetry at the VS Code level, Cline's telemetry will automatically be disabled as well.