Skip to content
Back to search

MCP-Repository

Practice MCP Server - Visual Studio Code

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/ftorresapexsystems--mcp-repository/badge.svg)](/listings/ftorresapexsystems--mcp-repository)

HTML

<a href="/listings/ftorresapexsystems--mcp-repository"><img src="/api/listings/ftorresapexsystems--mcp-repository/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 363 lines
  1. # GitHub MCP Server with GitHub Copilot
  2. ## Hands-On Practice
  3. **Estimated Duration:** 30–35 minutes
  4. **Team Size:** 2–3 participants
  5. **Level:** Beginner
  6. **Environment:** Visual Studio Code + GitHub Copilot + GitHub MCP Server
  7. ## Practice Objectives
  8. By the end of this practice, participants will be able to:
  9. - Understand the basic purpose of MCP.
  10. - Explain how GitHub Copilot interacts with an MCP Server.
  11. - Install and activate the GitHub MCP Server in Visual Studio Code.
  12. - Identify tools exposed by the GitHub MCP Server.
  13. - Use GitHub Copilot to retrieve information from a GitHub repository through MCP.
  14. - Use natural-language prompts to interact with GitHub resources.
  15. > **Practice scope:** The goal is not to explore every GitHub MCP capability. The goal is to demonstrate a simple end-to-end MCP interaction.
  16. ## Team Collaboration Rule
  17. Participants must work in **groups of 2–3 people**. Only one participant will operate and share the computer during the practice.
  18. ### Driver
  19. One participant will be the **Driver**. The Driver must:
  20. - Share the Driver's screen with the group.
  21. - Perform all installations and configurations.
  22. - Enter commands and prompts.
  23. - Interact with Visual Studio Code and GitHub.
  24. ### Navigators
  25. The remaining participants will be the **Navigators**. Navigators must:
  26. - Read the instructions.
  27. - Guide the Driver through each step.
  28. - Explain what needs to be done next.
  29. - Verify that each step has been completed correctly.
  30. - Help troubleshoot simple problems if necessary.
  31. > **Universal Rule:** Only the Driver operates the computer. The Navigators guide the Driver through the practice.
  32. ## Requirements
  33. **Estimated time: 5 minutes**
  34. Before starting the practice, verify the following requirements.
  35. ### 1. GitHub Account
  36. If the Driver does not already have a GitHub account, create one at [GitHub Sign Up](https://github.com/signup).
  37. > **Very important:** Do not use a personal email address when creating the account. Use your official Apex email address.
  38. ![GitHub account sign-up page](assets/github-signup.png)
  39. ### 2. Visual Studio Code
  40. **Visual Studio Code is required.**
  41. > ⚠️ **Important:** Visual Studio Code and Microsoft Visual Studio are different products. Having Microsoft Visual Studio installed does not mean Visual Studio Code is installed.
  42. Download Visual Studio Code from [Visual Studio Code Download](https://code.visualstudio.com/Download).
  43. ![Visual Studio Code download page](assets/vscode-download.png)
  44. After installing Visual Studio Code:
  45. - Open Visual Studio Code.
  46. - Sign in to GitHub if requested.
  47. - Verify that GitHub Copilot is available.
  48. ### 3. GitHub Copilot
  49. After signing in to the GitHub account, open the [GitHub Copilot Plans](https://github.com/features/copilot/plans) page. Under the **Free** plan, select **Open in VS Code**.
  50. > **Important:** Choose the **Free** plan. Do not select a paid plan for this practice.
  51. ![GitHub Copilot Free plan](assets/copilot-free-plan.png)
  52. If the browser asks for permission to open Visual Studio Code, select **Open**.
  53. ![Open GitHub Copilot in Visual Studio Code](assets/open-in-vscode.png)
  54. ---
  55. ## Part 1: Install the GitHub MCP Server
  56. **Estimated time: 8 minutes**
  57. ### Step 1: Open Visual Studio Code
  58. Launch **Visual Studio Code** and verify that GitHub Copilot is available.
  59. ![Visual Studio Code home screen](assets/vscode-home.png)
  60. ### Step 2: Open Customizations
  61. Press **Ctrl + Shift + P**, search for **Chat: Open Customizations**, open the command, and select **Browse**.
  62. ![Visual Studio Code Command Palette](assets/command-palette.png)
  63. ![Chat Open Customizations command](assets/open-customizations.png)
  64. ### Step 3: Find the GitHub MCP Server
  65. 1. In **Browse Customizations**, search for `@type:mcp github`.
  66. 2. Locate **GitHub MCP Server**.
  67. 3. Verify that the server is provided through the **GitHub Feed**.
  68. 4. Select **Install**.
  69. > **Note:** If Visual Studio Code asks whether the server is trusted, review the prompt and confirm it.
  70. ![Install GitHub MCP Server](assets/install-github-mcp-server.png)
  71. ### Step 4: Verify the Installation
  72. Navigate to **Customizations → MCP Servers**, locate **github-mcp-server**, and make sure the server is enabled.
  73. ![Verify GitHub MCP Server installation](assets/verify-mcp-server.png)
  74. > **Note:** A Personal Access Token (PAT), custom authorization headers, and manual JSON configuration are not required for this introductory practice.
  75. ---
  76. ## Part 2: Activate MCP and Explore the Tools
  77. **Estimated time: 7 minutes**
  78. ### Step 1: Start a Copilot Chat Session
  79. Open **GitHub Copilot Chat**, start a new session, and use the Copilot **Agent** functionality. Send the following message:
  80. > Hello. We are testing the GitHub MCP Server.
  81. This initializes the Copilot session before testing the MCP Server.
  82. ![Start a GitHub Copilot session](assets/start-copilot-session.png)
  83. ### Step 2: Verify the MCP Server
  84. 1. Return to **Customizations → MCP Servers**.
  85. 2. Locate **github-mcp-server**.
  86. 3. If necessary, start the server.
  87. When the server is already running, Visual Studio Code may display **Stop Server** instead of **Start**. This indicates that the MCP Server is active.
  88. ### Step 3: Explore the Available MCP Tools
  89. Navigate to **Customizations → Tools**, expand **github-mcp-server**, and review the available GitHub tools. Participants may see capabilities related to:
  90. - Repository contents
  91. - Commits
  92. - Branches
  93. - Issues
  94. - Pull requests
  95. - GitHub Actions
  96. ![Open the Tools section](assets/tools-menu.png)
  97. ![GitHub MCP Server tools](assets/github-mcp-tools.png)
  98. ### Troubleshooting
  99. If the MCP Server does not start, follow the Visual Studio Code instructions to refresh the GitHub/Copilot session using the sign-in process. After resolving the sign-in issue, return to **Customizations → Tools** and verify that the **github-mcp-server** tools are listed.
  100. ![Authenticated GitHub MCP Server tools](assets/github-mcp-tools-authenticated.png)
  101. ### Checkpoint 1
  102. Before continuing, the Navigators must verify:
  103. - [ ] GitHub MCP Server is installed.
  104. - [ ] github-mcp-server is enabled.
  105. - [ ] github-mcp-server is running.
  106. - [ ] GitHub MCP tools appear under Tools.
  107. If all four conditions are met, the MCP setup is complete. Otherwise, review the **Troubleshooting** section or ask the mentor for help.
  108. ---
  109. ## Part 3: Put MCP to Work
  110. **Estimated time: 10 minutes**
  111. ### Step 1: Create a Practice Repository
  112. Open GitHub and create a repository named **mcp-practice** with the following configuration:
  113. - **Visibility:** Public
  114. - **Initialize repository:** Add a README file
  115. > **Note:** If the repository name is already in use under the account, use a variation such as `mcp-practice-your-full-name`.
  116. ![Create the practice repository](assets/create-repository.png)
  117. ### Step 2: Add Simple Repository Content
  118. Open `README.md`, edit the file, and add:
  119. ```markdown
  120. # MCP Practice
  121. Simple repository to practice GitHub MCP Server with GitHub Copilot.
  122. ## Goals
  123. - Connect GitHub Copilot with GitHub MCP Server
  124. - Retrieve repository information using MCP tools
  125. - Explore GitHub issues using natural language
  126. ```
  127. Commit the changes.
  128. ### Step 3: Ask Copilot About the Repository
  129. Return to **GitHub Copilot Chat** in Visual Studio Code. Identify the repository using the format **GitHub username/repository name**. For example: `johnsmith/mcp-practice`.
  130. Then ask Copilot:
  131. > Using the GitHub MCP tools, get information about the repository johnsmith/mcp-practice and summarize what it contains.
  132. ![Edit the repository README](assets/edit-readme.png)
  133. Replace `johnsmith` with the GitHub username used to create the repository. If a different repository name was used, replace `mcp-practice` as well. Observe how Copilot uses the GitHub MCP tools to retrieve the repository information.
  134. > **Permission prompt:** If Copilot asks for permission one or more times, select **Allow Once** after reviewing the requested tool action.
  135. ![Repository prompt in GitHub Copilot Chat](assets/copilot-repository-prompt.png)
  136. #### Expected Result
  137. Copilot uses one or more tools identified as **github-mcp-server (MCP Server)** and returns a summary of the repository.
  138. ![Expected repository summary](assets/repository-summary.png)
  139. #### Troubleshooting
  140. If Copilot responds with a message such as **“I couldn’t access GitHub MCP tools in this session,”** follow these steps:
  141. 1. Close the existing chat session.
  142. 2. Open a new chat using the **+** icon in the top menu.
  143. 3. Make sure the chat is using **Agent** mode. From the **+** menu at the bottom of the chat, select **Agent** instead of the default option.
  144. 4. Press **Ctrl + Shift + P** and open **Chat: Open Customizations**.
  145. 5. Open **Tools** and confirm that the Built-in **github-mcp-server** is signed in, running, and displaying its tools without errors.
  146. 6. Return to the new chat and enter the prompt again:
  147. > Using the GitHub MCP tools, get information about the repository `<your-username>/<your-repository-name>` and summarize what it contains.
  148. ### Checkpoint 2
  149. Verify:
  150. - [ ] Copilot accepted the prompt.
  151. - [ ] A GitHub MCP tool was used.
  152. - [ ] Repository information was retrieved.
  153. - [ ] Copilot summarized the repository.
  154. At this point, the group has successfully demonstrated an end-to-end MCP interaction.
  155. ### Step 4: Create a GitHub Issue
  156. Open the practice repository in GitHub and select **Issues → New issue**.
  157. ![Open the repository Issues section](assets/issues-tab.png)
  158. Complete the form using the following information:
  159. - **Title:** `Add installation instructions by <YOUR FULL NAME>`
  160. - **Description:** `Add installation instructions to the README file by <YOUR FULL NAME>.`
  161. Replace `<YOUR FULL NAME>` with the Driver's full name, and select **Create**.
  162. ![Create the GitHub Issue](assets/create-issue.png)
  163. #### Expected Result
  164. The issue appears as an open issue in the practice repository.
  165. ![Expected created issue](assets/issue-created.png)
  166. ### Step 5: Ask Copilot to Retrieve the Issue
  167. Before entering the prompt, make sure the current chat session is still using **Agent** mode.
  168. ![Select Agent mode](assets/select-agent-mode.png)
  169. Return to **GitHub Copilot Chat** in Visual Studio Code. Confirm that Copilot Agent is active and the **github-mcp-server** tools are enabled. Then ask:
  170. > Using the GitHub MCP tools, list the open issues in `<your-username>/<your-repository-name>` and briefly summarize them.
  171. Replace `<your-username>/<your-repository-name>` with the actual repository identifier. Copilot should use a tool from **github-mcp-server** to retrieve the issue created in the previous step.
  172. > **Important:** Verify that Copilot actually invokes a GitHub MCP tool. If Copilot retrieves the information using another method, the MCP test is not considered successful.
  173. ![Ask Copilot to retrieve the issue](assets/issue-prompt.png)
  174. ### Checkpoint 3
  175. - [ ] Copilot used a github-mcp-server tool.
  176. - [ ] Copilot found the open issue.
  177. - [ ] Copilot summarized the issue correctly.
  178. #### Expected Result
  179. Copilot displays the MCP tool activity and returns the issue created by the group.
  180. ![GitHub MCP issue tool activity](assets/mcp-issue-tool.png)
  181. ![Expected issue result](assets/issue-result.png)
  182. ### Step 6: Review the MCP Tools Used
  183. Review the tool activity shown in GitHub Copilot Chat and identify which GitHub MCP tool was used to complete the request. If needed, return to **Customizations → Tools → github-mcp-server** and compare it with the available tools.
  184. The key observation is that Copilot is not accessing GitHub only through the local project. The Agent is using a capability exposed by the GitHub MCP Server to interact with GitHub.
  185. #### Expected Result
  186. The activity shows a tool such as **List issues - github-mcp-server (MCP Server)**.
  187. ![Review GitHub MCP tool activity](assets/review-tool-activity.png)
  188. ---
  189. ## Final Validation
  190. Before completing the practice, verify:
  191. - [ ] GitHub MCP Server is installed and running.
  192. - [ ] GitHub MCP tools are enabled in the Copilot session.
  193. - [ ] Copilot successfully retrieved repository information using MCP.
  194. - [ ] A GitHub Issue was created.
  195. - [ ] Copilot successfully retrieved the Issue using MCP.
  196. - [ ] Participants identified at least one MCP tool used by Copilot.
  197. ## Practice Complete
  198. The group has now implemented the following workflow:
  199. ![GitHub Copilot MCP workflow](assets/github-copilot-mcp-workflow.png)
  200. ## Remember
  201. MCP provides the standardized connection between the AI agent and external tools or services, while GitHub Copilot provides the conversational agent experience that decides how and when those tools should be used.
  202. ## Key Takeaways
  203. - GitHub Copilot provides the AI Agent experience.
  204. - MCP provides a standard way for the Agent to connect to external capabilities.
  205. - GitHub MCP Server exposes GitHub capabilities as tools.
  206. - The Agent can select and use these tools based on natural-language requests.
  207. - MCP enables Copilot to interact with resources beyond the local editor context.
  208. - A manual PAT configuration is not required for this introductory setup.
  209. > **Final concept:** GitHub Copilot is the Agent, GitHub MCP Server provides the tools, and MCP provides the connection between them.
  210. **Total estimated duration: approximately 30–35 minutes.**

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.