मॉडल कॉन्टेक्स्ट प्रोटोकॉल (MCP): डेमो प्रोजेक्ट सहित मार्गदर्शिका

Model Context Protocol (MCP) एक ओपन स्टैंडर्ड है जो बड़े भाषा मॉडलों को एक मानकीकृत इंटरफ़ेस के माध्यम से बाहरी टूल्स, डेटाबेस, और APIs के साथ गतिशील रूप से इंटरैक्ट करने में सक्षम बनाता है।

इस ब्लॉग में, मैं आपको Claude Desktop के साथ इंटीग्रेट होने वाला MCP-संचालित PR रिव्यू सर्वर बनाना सिखाऊँगा। यह सर्वर निम्न कार्य करेगा:

GitHub से PR विवरण और बदली हुई फाइलें लाना
Claude Desktop एप्लिकेशन का उपयोग करके कोड परिवर्तनों का विश्लेषण
PR रिव्यू सारांश और सुझाव तैयार करना
रिव्यू Notion में सहेजना

हम सर्वर और Claude Desktop के बीच संचार को मानकीकृत करने के लिए Model Context Protocol (MCP) का उपयोग करेंगे, जिससे यह मॉड्यूलर और स्केलेबल बनता है।

हम अपने पाठकों को AI की ताज़ा जानकारी से अपडेट रखते हैं अपनी मुफ्त शुक्रवार की न्यूज़लेटर The Median के माध्यम से, जो हफ्ते की प्रमुख कहानियाँ सरलता से समझाती है। सदस्यता लें और हर सप्ताह कुछ ही मिनटों में तेज रखें:

Model Context Protocol (MCP) क्या है?

Model Context Protocol (MCP) Anthropic द्वारा विकसित एक ओपन स्टैंडर्ड है जो AI मॉडलों और बाहरी टूल्स के बीच आसान और मानकीकृत इंटीग्रेशन सक्षम करता है। यह एक सार्वभौमिक कनेक्टर की तरह काम करता है, जिससे बड़े भाषा मॉडल (LLMs) APIs, डेटाबेस और व्यावसायिक एप्लिकेशनों के साथ गतिशील रूप से इंटरैक्ट कर सकते हैं।

मूल रूप से Claude की बाहरी सिस्टम्स के साथ इंटरैक्ट करने की क्षमता को बेहतर बनाने के लिए बनाया गया, Anthropic ने 2024 की शुरुआत में MCP को ओपन-सोर्स कर दिया ताकि उद्योग-स्तरीय अपनाने को प्रोत्साहन मिले। MCP को सार्वजनिक कर, उनका उद्देश्य AI-टू-टूल संचार के लिए एक मानकीकृत ढांचा बनाना था, जिससे स्वामित्व-आधारित इंटीग्रेशन पर निर्भरता कम हो और AI एप्लिकेशनों में अधिक मॉड्यूलैरिटी और इंटरऑपरेबिलिटी संभव हो सके।

MCP एक क्लाइंट-सर्वर आर्किटेक्चर का पालन करता है, जहाँ:

MCP क्लाइंट्स (जैसे, Claude Desktop) जानकारी का अनुरोध करते हैं और कार्य निष्पादित करते हैं।
MCP सर्वर बाहरी टूल्स और डेटा स्रोतों तक पहुंच प्रदान करते हैं।
होस्ट एप्लिकेशन मॉडल्स और टूल्स के बीच संचार के लिए MCP का उपयोग करते हैं।

स्रोत: Model Context Protocol

यहाँ वे कारण हैं जिनकी वजह से आप अपने प्रोजेक्ट्स में MCP का उपयोग करना चाहेंगे:

मानकीकृत AI इंटीग्रेशन: MCP AI मॉडलों को टूल्स से जोड़ने का संरचित तरीका प्रदान करता है।
लचीलापन: यह अलग-अलग AI मॉडलों और वेंडर्स के बीच आसानी से स्विच करने देता है।
सुरक्षा: AI के साथ इंटरैक्ट करते समय आपका डेटा आपके इंफ्रास्ट्रक्चर के भीतर रहता है।
स्केलेबिलिटी: MCP stdio, WebSockets, HTTP SSE और UNIX सॉकेट्स जैसे विभिन्न ट्रांसपोर्ट्स को सपोर्ट करता है।

MCP डेमो प्रोजेक्ट ओवरव्यू: PR रिव्यू सर्वर

PR रिव्यू सिस्टम Claude Desktop और Notion का उपयोग करके कोड विश्लेषण और दस्तावेज़ीकरण को स्वचालित करता है।

यहाँ पाइपलाइन का संक्षिप्त विवरण है:

एन्वायरनमेंट सेटअप: GitHub और Notion क्रेडेंशियल्स लोड करें।
सर्वर इनिशियलाइज़ेशन: Claude Desktop से संचार करने के लिए MCP सर्वर शुरू करें।
PR डेटा लाना: GitHub से PR परिवर्तन और मेटाडेटा प्राप्त करें।
कोड विश्लेषण: Claude Desktop सीधे कोड परिवर्तनों का विश्लेषण करता है (अलग टूल की जरूरत नहीं)।
Notion दस्तावेज़ीकरण: ट्रैकिंग के लिए विश्लेषण परिणाम Notion में सहेजें।

चरण 1: एन्वायरनमेंट सेट करना

शुरू करने से पहले, सुनिश्चित करें कि आपके पास Python 3.10+ इंस्टॉल है। फिर, हम अपना एन्वायरनमेंट सेट करते हैं और uv पैकेज मैनेजर इंस्टॉल करने से शुरू करते हैं। Mac या Linux के लिए:

curl -LsSf https://astral.sh/uv/install.sh | sh  # Mac/Linuxसंचालित द्वारा

Windows (PowerShell) के लिए:

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"संचालित द्वारा

इसके बाद, हम एक नया प्रोजेक्ट डायरेक्टरी बनाते हैं और उसे uv से इनिशियलाइज़ करते हैं:

uv init pr_reviewer
cd pr_reviewerसंचालित द्वारा

अब हम वर्चुअल एन्वायरनमेंट बना और सक्रिय कर सकते हैं। Mac या Linux के लिए:

uv venv
source .venv/bin/activateसंचालित द्वारा

Windows के लिए:

.venv\Scripts\activateसंचालित द्वारा

अब हम आवश्यक निर्भरताएँ इंस्टॉल करते हैं:

uv add "mcp[cli]" requests python-dotenv notion-clientसंचालित द्वारा

हम इस प्रोजेक्ट के लिए conda की बजाय uv का उपयोग करेंगे क्योंकि यह तेज़, हल्का और Python पैकेज मैनेजमेंट पर अधिक केंद्रित है। आइए संक्षेप में देखें कि हमने अभी क्या किया:

हमने uv पैकेज मैनेजर का उपयोग करके GitHub PR Review MCP सर्वर का डेवलपमेंट एन्वायरनमेंट सेट किया
हमने pr_reviewer नामक नई प्रोजेक्ट डायरेक्टरी इनिशियलाइज़ की और उसमें गए।
हमने एक वर्चुअल एन्वायरनमेंट बनाया और उसे सक्रिय किया ताकि पैकेज इंस्टॉलेशन आइसोलेटेड रहें।

चरण 2: निर्भरताएँ इंस्टॉल करें

एक बार हमारा एन्वायरनमेंट सेट हो जाने के बाद, हम API कीज़ और अन्य आवश्यकताओं के साथ निर्भरताएँ सेट करते हैं। requirements.txt फाइल बनाएँ और इसमें निम्न Python पैकेज जोड़ें:

# Core dependencies for PR Analyzer
requests>=2.31.0          # For GitHub API calls
python-dotenv>=1.0.0      # For environment variables
mcp[cli]>=1.4.0          # For MCP server functionality
notion-client>=2.3.0      # For Notion integration

# Optional: Pin versions for stability
# requests==2.31.0
# python-dotenv==1.0.0
# mcp[cli]==1.4.0
# notion-client==2.3.0
संचालित द्वारा

requirements.txt फाइल में प्रोजेक्ट के लिए सभी कोर निर्भरताएँ शामिल हैं। निर्भरताएँ सेट करने के लिए, निम्न में से कोई एक कमांड चलाएँ (यदि आपने पहले uv इंस्टॉल किया है तो उसे प्राथमिकता दें)।

uv pip install -r requirements.txt
pip install -r requirements.txtसंचालित द्वारा

अब आपके एन्वायरनमेंट में सभी आवश्यक निर्भरताएँ इंस्टॉल हो गई हैं।

चरण 3: एन्वायरनमेंट वेरिएबल्स सेट करना

इसके बाद, हम एक .env फाइल बनाते हैं जिसमें इस प्रोजेक्ट के लिए आवश्यक सभी कीज़ और टोकन शामिल होंगे।

GitHub टोकन जनरेट करना

GitHub टोकन जनरेट करने के लिए:

अपने GitHub अकाउंट में लॉगिन करें और सेटिंग्स पर जाएँ।
डेवलपर सेटिंग्स → Personal Access Tokens पर जाएँ।
Generate New Token पर क्लिक करें और क्लासिक संस्करण चुनें।
टोकन के लिए नाम दें और निम्न अनुमतियाँ सक्षम करें:

read:org
read:repo_hook
repo

टोकन बनाने के लिए Generate पर क्लिक करें।
टोकन को कॉपी कर सुरक्षित रखें, क्योंकि API अनुरोधों में प्रमाणीकरण के लिए इसका उपयोग होगा।

Notion इंटीग्रेशन

Notion के इंटीग्रेशन पेज में लॉगिन करें।
एक नया इंटीग्रेशन बनाएँ और फॉर्म पूरा करें। “type” को Internal पर रखें और इसे अपने वर्कस्पेस में जोड़ें।

इंटीग्रेशन सेव करें और इंटीग्रेशन लिंक कॉपी करें (URL के अंत में दिया गया UUID यूनिवर्सली यूनिक आइडेंटिफ़ायर होता है, जिसे नोट करें और Notion Page ID के रूप में उपयोग करें)।

https://www.notion.so/profile/integrations/internal/UUIDसंचालित द्वारा

इंटीग्रेशन बन जाने के बाद, उस पर क्लिक करें, और कॉन्फ़िगरेशन के तहत Internal Integration Secret कॉपी करें, जो आपका Notion API key होगा।

`.env` फाइल बनाना

अब एक .env फाइल बनाएँ और ऊपर जनरेट की गई API कीज़ और टोकन के साथ निम्न टेक्स्ट जोड़ें।

GITHUB_TOKEN=your_github_token
NOTION_API_KEY=your_notion_api_key
NOTION_PAGE_ID=your_notion_page_idसंचालित द्वारा

चरण 4: GitHub इंटीग्रेशन

आइए GitHub इंटीग्रेशन मॉड्यूल को कॉन्फ़िगर करें ताकि किसी GitHub रिपॉज़िटरी से PR परिवर्तन मैनेज और प्राप्त किए जा सकें।

एक github_integration.py फाइल बनाएँ और निम्न कोड लिखें (हम इसे थोड़ी देर में समझाएँगे)।

import os
import requests
import traceback
from dotenv import load_dotenv

# Load environment variables
load_dotenv()
GITHUB_TOKEN = os.getenv('GITHUB_TOKEN')

def fetch_pr_changes(repo_owner: str, repo_name: str, pr_number: int) -> list:
    """Fetch changes from a GitHub pull request.
    
    Args:
        repo_owner: The owner of the GitHub repository
        repo_name: The name of the GitHub repository
        pr_number: The number of the pull request to analyze
        
    Returns:
        A list of file changes with detailed information about each change
    """
    print(f" Fetching PR changes for {repo_owner}/{repo_name}#{pr_number}")
    
    # Fetch PR details
    pr_url = f"https://api.github.com/repos/{repo_owner}/{repo_name}/pulls/{pr_number}"
    files_url = f"{pr_url}/files"
    headers = {'Authorization': f'token {GITHUB_TOKEN}'}
    
    try:
        # Get PR metadata
        pr_response = requests.get(pr_url, headers=headers)
        pr_response.raise_for_status()
        pr_data = pr_response.json()
        
        # Get file changes
        files_response = requests.get(files_url, headers=headers)
        files_response.raise_for_status()
        files_data = files_response.json()
        
        # Combine PR metadata with file changes
        changes = []
        for file in files_data:
            change = {
                'filename': file['filename'],
                'status': file['status'],  # added, modified, removed
                'additions': file['additions'],
                'deletions': file['deletions'],
                'changes': file['changes'],
                'patch': file.get('patch', ''),  # The actual diff
                'raw_url': file.get('raw_url', ''),
                'contents_url': file.get('contents_url', '')
            }
            changes.append(change)
        
        # Add PR metadata
        pr_info = {
            'title': pr_data['title'],
            'description': pr_data['body'],
            'author': pr_data['user']['login'],
            'created_at': pr_data['created_at'],
            'updated_at': pr_data['updated_at'],
            'state': pr_data['state'],
            'total_changes': len(changes),
            'changes': changes
        }
        
        print(f"Successfully fetched {len(changes)} changes")
        return pr_info
        
    except Exception as e:
        print(f"Error fetching PR changes: {str(e)}")
        traceback.print_exc()
        return None

# Example usage for debugging
# pr_data = fetch_pr_changes('owner', 'repo', 1)
# print(pr_data) संचालित द्वारा

fetch_pr_changes() फ़ंक्शन दिए गए GitHub पुल रिक्वेस्ट से परिवर्तन प्राप्त करता है और लौटाता है। यह तीन पैरामीटर्स लेता है: repo_owner, repo_name, और pr_number, और फाइल-स्तरीय परिवर्तनों की एक संरचित सूची PR मेटाडेटा सहित लौटाता है।

कोड requests लाइब्रेरी का उपयोग करके प्रमाणित HTTP GET अनुरोध भेजता है, जिससे सामान्य PR मेटाडेटा और फाइल-स्तरीय विस्तृत परिवर्तन दोनों प्राप्त होते हैं:

पहला API अनुरोध उच्च-स्तरीय PR जानकारी लाता है, जिसमें शीर्षक, विवरण, लेखक विवरण, टाइमस्टैम्प्स और वर्तमान स्थिति शामिल हैं।
दूसरा API अनुरोध PR में बदली गई प्रत्येक फाइल के बारे में विवरण लाता है, जैसे फाइलनाम, संशोधन स्थिति, जोड़ी या हटाई गई पंक्तियों की संख्या, और फाइल सामग्री तक पहुँचने के लिए URLs।

डेटा प्राप्त होने के बाद, फ़ंक्शन PR मेटाडेटा को फाइल परिवर्तनों के साथ संरचित कर एक डिक्शनरी में जोड़ता है। फाइल परिवर्तन एक सूची में स्टोर होते हैं, जहाँ प्रत्येक एंट्री में किसी फाइल के बारे में विस्तृत जानकारी होती है। अंतिम डेटा स्ट्रक्चर में PR शीर्षक, विवरण, लेखक, टाइमस्टैम्प्स, स्थिति, बदली गई फाइलों की कुल गिनती, और फाइल संशोधनों का विस्तृत विवरण शामिल होता है।

चरण 5: MCP सर्वर लागू करें

अब जब हमारे पास सभी निर्भरताएँ और अतिरिक्त फ़ंक्शंस हैं, हम अपना MCP सर्वर सेट करते हैं। हम pr_analyzer.py फाइल बनाते हैं, जो:

एक MCP सर्वर इनिशियलाइज़ करेगा।
PR विवरण लाने, कोड का विश्लेषण करने और परिणाम Notion में स्टोर करने के टूल्स परिभाषित करेगा।
इन टूल्स को Claude Desktop के लिए उपलब्ध कराएगा ताकि सारांश, संभावित समाधान आदि बनाए जा सकें।

पहले कोड जोड़ते हैं और फिर इसे समझाते हैं

import sys
import os
import traceback
from typing import Any, List, Dict
from mcp.server.fastmcp import FastMCP
from github_integration import fetch_pr_changes
from notion_client import Client
from dotenv import load_dotenv

class PRAnalyzer:
    def __init__(self):
        # Load environment variables
        load_dotenv()
        
        # Initialize MCP Server
        self.mcp = FastMCP("github_pr_analysis")
        print("MCP Server initialized", file=sys.stderr)
        
        # Initialize Notion client
        self._init_notion()
        
        # Register MCP tools
        self._register_tools()
    
    def _init_notion(self):
        """Initialize the Notion client with API key and page ID."""
        try:
            self.notion_api_key = os.getenv("NOTION_API_KEY")
            self.notion_page_id = os.getenv("NOTION_PAGE_ID")
            
            if not self.notion_api_key or not self.notion_page_id:
                raise ValueError("Missing Notion API key or page ID in environment variables")
            
            self.notion = Client(auth=self.notion_api_key)
            print(f"Notion client initialized successfully", file=sys.stderr)
            print(f"Using Notion page ID: {self.notion_page_id}", file=sys.stderr)
        except Exception as e:
            print(f"Error initializing Notion client: {str(e)}", file=sys.stderr)
            traceback.print_exc(file=sys.stderr)
            sys.exit(1)
    
    def _register_tools(self):
        """Register MCP tools for PR analysis."""
        @self.mcp.tool()
        async def fetch_pr(repo_owner: str, repo_name: str, pr_number: int) -> Dict[str, Any]:
            """Fetch changes from a GitHub pull request."""
            print(f"Fetching PR #{pr_number} from {repo_owner}/{repo_name}", file=sys.stderr)
            try:
                pr_info = fetch_pr_changes(repo_owner, repo_name, pr_number)
                if pr_info is None:
                    print("No changes returned from fetch_pr_changes", file=sys.stderr)
                    return {}
                print(f"Successfully fetched PR information", file=sys.stderr)
                return pr_info
            except Exception as e:
                print(f"Error fetching PR: {str(e)}", file=sys.stderr)
                traceback.print_exc(file=sys.stderr)
                return {}
        
        @self.mcp.tool()
        async def create_notion_page(title: str, content: str) -> str:
            """Create a Notion page with PR analysis."""
            print(f"Creating Notion page: {title}", file=sys.stderr)
            try:
                self.notion.pages.create(
                    parent={"type": "page_id", "page_id": self.notion_page_id},
                    properties={"title": {"title": [{"text": {"content": title}}]}},
                    children=[{
                        "object": "block",
                        "type": "paragraph",
                        "paragraph": {
                            "rich_text": [{
                                "type": "text",
                                "text": {"content": content}
                            }]
                        }
                    }]
                )
                print(f"Notion page '{title}' created successfully!", file=sys.stderr)
                return f"Notion page '{title}' created successfully!"
            except Exception as e:
                error_msg = f"Error creating Notion page: {str(e)}"
                print(error_msg, file=sys.stderr)
                traceback.print_exc(file=sys.stderr)
                return error_msg
    
    def run(self):
        """Start the MCP server."""
        try:
            print("Running MCP Server for GitHub PR Analysis...", file=sys.stderr)
            self.mcp.run(transport="stdio")
        except Exception as e:
            print(f"Fatal Error in MCP Server: {str(e)}", file=sys.stderr)
            traceback.print_exc(file=sys.stderr)
            sys.exit(1)

if __name__ == "__main__":
    analyzer = PRAnalyzer()
    analyzer.run() संचालित द्वारा

ऊपर दिया गया कोड एक MCP सर्वर सेट करता है जो GitHub PR परिवर्तनों को लाता है और विश्लेषण परिणाम Notion में स्टोर करता है। आइए मुख्य घटकों पर नज़र डालें:

एन्वायरनमेंट सेटअप और इनिशियलाइज़ेशन

dotenv मॉड्यूल एन्वायरनमेंट वेरिएबल्स लोड करता है, जिससे API कीज़ और क्रेडेंशियल्स सुरक्षित रूप से एक्सेस होते हैं।
PRAnalyzer क्लास FastMCP() फ़ंक्शन का उपयोग करके एक MCP सर्वर इनिशियलाइज़ करती है, जो MCP सर्वर को github_pr_analysis नाम से शुरू करता है और Claude Desktop एप्लिकेशन के साथ इंटरैक्शन सक्षम करता है।
Notion क्लाइंट भी notion-client पैकेज से सेटअप होता है, जो .env फाइल में संग्रहीत Notion API key और page ID का उपयोग करता है।

MCP टूल: PR परिवर्तन लाना

fetch_pr() फ़ंक्शन github_integration.py फाइल के fetch_pr_changes() मेथड का उपयोग करते हुए GitHub से पुल रिक्वेस्ट मेटाडेटा लाता है। सफल होने पर यह PR विवरण युक्त डिक्शनरी लौटाता है।
आप इस प्रक्रिया को GitHub में अंतर्निर्मित Webhooks लाइब्रेरी का उपयोग कर स्वचालित कर सकते हैं ताकि आपकी रिपॉज़िटरी पर बना कोई भी नया PR स्वतः सर्वर द्वारा प्रोसेस हो जाए।

MCP टूल: Notion पेज बनाना

create_notion_page() फ़ंक्शन PR विश्लेषण परिणामों के साथ एक Notion पेज जनरेट करता है।
यह Notion API का उपयोग कर निर्दिष्ट Notion वर्कस्पेस के अंतर्गत नया पेज बनाता है।

सर्वर निष्पादन

run() मेथड mcp.run(transport="stdio") का उपयोग करके MCP सर्वर शुरू करता है, जिससे Claude Desktop और PR रिव्यू टूल्स के बीच इंटरैक्शन सक्षम होता है।

चरण 6: MCP सर्वर चलाएँ

अब जब हमारे पास सभी कोड हिस्से मौजूद हैं, तो हम निम्न टर्मिनल कमांड से अपना सर्वर चलाते हैं:

python pr_analyzer.pyसंचालित द्वारा

सर्वर के चालू हो जाने पर, Claude Desktop एप्लिकेशन खोलें, और आपको टेक्स्टबॉक्स में एक प्लग आइकन (🔌) दिखाई देगा। यह प्लग Claude वातावरण में MCP की उपस्थिति दर्शाता है। इसी टेक्स्टबॉक्स में, आपको एक हथौड़े जैसा आइकन (🔨) भी दिखेगा जो सभी उपलब्ध MCPs दिखाता है, जैसा कि नीचे दर्शाया गया है।

अब वह PR लिंक भेजें जिसे आप विश्लेषित करना चाहते हैं और आगे का काम Claude आपके लिए कर देगा।

Claude पहले PR का विश्लेषण करेगा और फिर उसका सारांश और रिव्यू प्रदान करेगा। यह उपयोगकर्ताओं से पूछेगा कि क्या वे विवरण Notion पेज पर अपलोड करना चाहते हैं। आप इस प्रक्रिया को ऑटोमेट कर सकते हैं, लेकिन वर्तमान कोड आपको नया Notion पेज बनाने से पहले सारांश की समीक्षा करने देता है।

अपडेट किया गया Notion पेज इस प्रकार दिखता है:

निष्कर्ष

हमारा PR रिव्यू MCP-आधारित सर्वर कोड विश्लेषण और दस्तावेज़ीकरण में सुधार करता है, जिससे रिव्यू प्रक्रिया अधिक कुशल और सुव्यवस्थित बनती है। MCP, GitHub API, और Notion इंटीग्रेशन का उपयोग करके, यह सिस्टम स्वचालित PR विश्लेषण, आसान सहयोग, और संरचित दस्तावेज़ीकरण को सपोर्ट करता है। इस कॉन्फ़िगरेशन के साथ, डेवलपर्स जल्दी से PR विवरण प्राप्त कर सकते हैं, Claude का उपयोग कर कोड परिवर्तनों का विश्लेषण कर सकते हैं, और भविष्य के संदर्भ के लिए इनसाइट्स Notion में स्टोर कर सकते हैं।

और हालिया AI टूल्स को एक्सप्लोर करने के लिए, मैं ये ब्लॉग्स सुझाता/सुझाती हूँ:

लेखक

Aashi Dutt

LinkedIn Twitter

मैं एमएल (Gen AI) में Google Developers Expert, Kaggle 3x Expert, और Women Techmakers एंबेसडर हूँ, तथा तकनीक क्षेत्र में 3+ वर्षों का अनुभव रखती हूँ। मैंने 2020 में एक हेल्थ-टेक स्टार्टअप की सह-स्थापना की और वर्तमान में Georgia Tech से कंप्यूटर विज्ञान में मास्टर कर रही हूँ, जिसमें मेरा विशेषज्ञता क्षेत्र मशीन लर्निंग है।

विषय

कृत्रिम बुद्धिमत्ता बड़े भाषा मॉडल

प्रौद्योगिकियाँ

विषय

मॉडल कॉन्टेक्स्ट प्रोटोकॉल (MCP): डेमो प्रोजेक्ट सहित मार्गदर्शिका

AI के साथ खोजें

Model Context Protocol (MCP) क्या है?

MCP डेमो प्रोजेक्ट ओवरव्यू: PR रिव्यू सर्वर

चरण 1: एन्वायरनमेंट सेट करना

चरण 2: निर्भरताएँ इंस्टॉल करें

चरण 3: एन्वायरनमेंट वेरिएबल्स सेट करना

GitHub टोकन जनरेट करना

Notion इंटीग्रेशन

`.env` फाइल बनाना

चरण 4: GitHub इंटीग्रेशन

चरण 5: MCP सर्वर लागू करें

चरण 6: MCP सर्वर चलाएँ

निष्कर्ष

विषय

इन कोर्सेज़ के साथ AI सीखें!

एआई अनुप्रयोग विकसित करना

LangChain के साथ Retrieval Augmented Generation (RAG)

EU AI Act को समझना

प्रौद्योगिकियाँ

विषय

इन कोर्सेज़ के साथ AI सीखें!

एआई अनुप्रयोग विकसित करना

LangChain के साथ Retrieval Augmented Generation (RAG)

EU AI Act को समझना

Model Context Protocol (MCP) क्या है?

MCP डेमो प्रोजेक्ट ओवरव्यू: PR रिव्यू सर्वर

चरण 1: एन्वायरनमेंट सेट करना

चरण 2: निर्भरताएँ इंस्टॉल करें

चरण 3: एन्वायरनमेंट वेरिएबल्स सेट करना

GitHub टोकन जनरेट करना

Notion इंटीग्रेशन

.env फाइल बनाना

चरण 4: GitHub इंटीग्रेशन

चरण 5: MCP सर्वर लागू करें

चरण 6: MCP सर्वर चलाएँ

निष्कर्ष

विषय

इन कोर्सेज़ के साथ AI सीखें!

एआई अनुप्रयोग विकसित करना

LangChain के साथ Retrieval Augmented Generation (RAG)

EU AI Act को समझना

इन कोर्सेज़ के साथ AI सीखें!

एआई अनुप्रयोग विकसित करना

LangChain के साथ Retrieval Augmented Generation (RAG)

EU AI Act को समझना

`.env` फाइल बनाना