Claude Opus 4.5 ट्यूटोरियल: एक GitHub Wiki एजेंट बनाएं

आधुनिक GitHub रिपॉज़िटरीज़ में अक्सर स्पष्ट, संरचित डॉक्यूमेंटेशन—खासतौर पर विकि—की कमी होती है।

इन पेजों को मैन्युअल रूप से बनाना कोड पढ़ने, आर्किटेक्चर समझने, और सामग्री व्यवस्थित करने में घंटों ले सकता है।

एक GitHub Wiki AI एजेंट इस समस्या का हल कर सकता है।

इस ट्यूटोरियल में, मैं आपको दिखाऊंगा कि कैसे एक पूरी तरह स्वचालित GitHub Wiki AI एजेंट बनाएं—एक कमांड-लाइन टूल जो Claude Opus 4.5 और Claude Agent SDK का उपयोग करके केवल एक निर्देश से संपूर्ण GitHub रिपॉज़िटरी विकि जनरेट करता है। 

डॉक्यूमेंटेशन को मैन्युअल रूप से लिखने के बजाय, यह टूल आपके कोडबेस का विश्लेषण करता है, उसकी संरचना समझता है, और साफ-सुथरी, मल्टी-पेज विकि सामग्री तैयार करता है जो स्वतः आपकी रिपॉज़िटरी में कमिट और प्रकाशित हो जाती है। 

सब कुछ एक इंटरैक्टिव CLI ऐप के जरिए चलता है, जिसे तेज़, बुद्धिमान और डेवलपर-फ्रेंडली अनुभव के लिए डिज़ाइन किया गया है।

इस गाइड में, हम एक सरल तीन-चरणीय प्रक्रिया का पालन करेंगे—पर्यावरण सेट करें, GitHub Wiki AI एजेंट बनाएं, और इसे वास्तविक रिपॉज़िटरीज़ पर टेस्ट करें:

1. पर्यावरण सेट करें: डिपेंडेंसीज़ इंस्टॉल करें, Claude Code को इंस्टॉल और ऑथेंटिकेट करें, GitHub टोकन कॉन्फ़िगर करें, और Wiki फीचर सक्षम करें।
2. एप्लिकेशन बनाएं: CLI टूल बनाएं, Claude Agent कॉन्फ़िगर करें, MCP GitHub टूल्स इंटीग्रेट करें, कॉस्ट ट्रैकिंग जोड़ें, और विकि-जनरेशन लॉजिक लागू करें (Home, Getting Started, Architecture & Tools)।
3. एजेंट का परीक्षण करें: इसे वास्तविक रिपॉज़िटरीज़ (ECom-Intel और Issue-Analyzer) पर चलाकर क्लोनिंग, विश्लेषण, विकि निर्माण, और स्वत: पुश की पुष्टि करें।

यदि आप AI एजेंट्स में नए हैं और अधिक सीखना चाहते हैं, तो मैं AI Agent Fundamentals स्किल ट्रैक देखने की सलाह देता/देती हूं। आपको हमारा Claude Cowork पर ट्यूटोरियल और नए Claude Opus 4.6 का गाइड भी पढ़ना चाहिए।

Claude Opus 4.5 GitHub Wiki ट्यूटोरियल के लिए अपना वातावरण सेट करना

Opus 4.5 के साथ GitHub Wiki एजेंट बनाने से पहले, सुनिश्चित करें कि आपका वातावरण सही तरह से कॉन्फ़िगर है। यह सेक्शन सभी पूर्वापेक्षाएँ और सेटअप चरण समझाता है।

1. Claude Opus 4.5 विकि एजेंट चलाने के लिए पूर्वापेक्षाएँ

• Python 3.11 या उससे ऊपर (Python Claude Agent SDK के लिए आवश्यक)।
• Node.js और npm (Claude Code इंस्टॉल करने के लिए आवश्यक), जो हमारे एप्लिकेशन की रीढ़ है और MCP सर्वर के लिए एजेंट्स, टूल्स, और इंटीग्रेशन प्रदान करता है।

2. Claude Code इंस्टॉल करें और ऑथेंटिकेट करें

अपना टर्मिनल (Command Prompt, PowerShell, या macOS Terminal) खोलें और Claude Code CLI इंस्टॉल करने के लिए निम्न कमांड चलाएं:

npm install -g @anthropic-ai/claude-code

अपने टर्मिनल में claude टाइप करें ताकि Claude Code शुरू हो जाए। फिर, Claude चैट के अंदर /login टाइप करें ताकि आप ऑथेंटिकेट होकर Opus 4.5 मॉडल और टूल्स तक पहुंच सकें, जैसा कि नीचे दिखाया गया है।

आप हमारे हैंड्स-ऑन ट्यूटोरियल में Claude Code के बारे में और जान सकते हैं। 

3. फाइन-ग्रेन्ड GitHub Personal Access Token जनरेट करें

फाइन-ग्रेन्ड GitHub Personal Access Token जनरेट करने के लिए, GitHub पर जाएं और इस पथ पर नेविगेट करें: 

Settings → Developer Settings → Personal Access Tokens → Fine-grained tokens. 

एक नया टोकन बनाएं और Repository सेक्शन के अंतर्गत वह रिपॉज़िटरी चुनें जिसे आप उपयोग करेंगे। फिर Permissions कॉन्फ़िगर करें। सुरक्षा के लिए, टोकन के लिए कम एक्सपायरी सेट करना अनुशंसित है।

फिर, Personal Access Token को वातावरण चर (environment variable) के रूप में सेट करें:

export GITHUB_PAT="your-github-personal-access-token"

4. अपना GitHub Wiki इनिशियलाइज़ करें

GitHub वर्तमान में पहले लोकली विकि बनाने का समर्थन नहीं करता।

इसलिए आपको विकि को मैन्युअल रूप से इनिशियलाइज़ करना होगा:

1. GitHub पर अपनी रिपॉज़िटरी खोलें
2. Wiki टैब पर क्लिक करें
3. “Create the first page” पर क्लिक करें
4. पेज सेव करें (कोई भी शीर्षक चल जाएगा)

5. Claude Agent SDK इंस्टॉल करें

हम Claude एजेंटिक फ्रेमवर्क इंस्टॉल करेंगे, जो MCP के उपयोग से लेकर टूल्स इनवोक करने, फ़ाइलें बनाने, और रिमोट पर बदलाव पुश करने तक सब संभालता है।

pip install claude-agent-sdk

Claude Opus 4.5 के साथ ऑटो विकि एजेंट बनाना

अब हम gh_wiki_cli.py नामक एक Python CLI एप्लिकेशन बनाएंगे। इस फ़ाइल में कॉन्फ़िगरेशन, एजेंट्स, टूल्स, एक MCP क्लाइंट, सिस्टम प्रॉम्प्ट्स, स्वयं CLI एप्लिकेशन, और हेल्पर फ़ंक्शंस शामिल होंगे। 

ये घटक सुनिश्चित करेंगे कि उपयोगकर्ता रिपॉज़िटरी का लिंक दे सके और एजेंट उसे सही ढंग से हैंडल करके GitHub विकि प्रकाशित करना जानता हो।

1. इम्पोर्ट्स

यह भाग Python stdlib मॉड्यूल्स, टाइपिंग हेल्पर्स, और Claude Agent SDK को शामिल करता है।

• asyncio असिंक I/O (चैट + स्ट्रीमिंग) के लिए।
• os, sys एन्वायरनमेंट वेरिएबल्स और एग्ज़िटिंग के लिए।
• dataclass स्टैट्स ट्रैक करने के लिए।
• Claude Agent SDK इम्पोर्ट्स—एजेंट और MCP टूल्स से बात करने के लिए।

import asyncio
import os
import sys
from dataclasses import dataclass
from typing import Dict

# --- SDK Imports ---
from claude_agent_sdk import (
    AssistantMessage,
    ClaudeAgentOptions,
    ClaudeSDKClient,
    McpSdkServerConfig,
    ResultMessage,
    TextBlock,
    ToolResultBlock,
    ToolUseBlock,
)

2. सिस्टम प्रॉम्प्ट

यह एजेंट का “ब्रेन” है। हम Opus 4.5 मॉडल को निर्देश देंगे कि इसे कैसे व्यवहार करना है और टूल्स कैसे उपयोग करने हैं।

SYSTEM_PROMPT = """
        You are an expert Technical Writer and GitHub Wiki specialist.

        TOOLS
        - Read, Write, Glob, Grep:
        - Use these to inspect files and folders in the project directory (e.g. /tmp/Issue-Analyzer) and in wiki_clone/.
        - Use them to list files, read contents, and search for patterns.
        - Write:
        - Use this ONLY to write or update three wiki pages inside wiki_clone/:
            - wiki_clone/Home.md
            - wiki_clone/Getting-Started.md
            - wiki_clone/Architecture-and-Tools.md
        - Bash:
        - Bash is ONLY allowed for git commands, never for inspection or editing.
        - Allowed commands (with cd wiki_clone/ when needed):
            - git clone <repo>.wiki.git wiki_clone  (if wiki_clone does not already exist)
            - git status
            - git add .
            - git commit -m "Update wiki"
            - git push
        - Do NOT use Bash for ls, cat, grep, find, python, or any other way of reading/writing files.

        WORKFLOW
        1. When the user gives a GitHub repo URL:
        - Use Bash to clone the wiki if wiki_clone/ does not already exist:
            git clone <repo>.wiki.git wiki_clone
        2. Use Read/Glob/Grep (and any GitHub MCP tools) to explore the project:
        - Read important files in the project folder (e.g. README, docs/, src/).
        - Use that information to generate documentation.
        3. Use Write to create or update ONLY:
        - wiki_clone/Home.md
        - wiki_clone/Getting-Started.md
        - wiki_clone/Architecture-and-Tools.md
        4. When the wiki pages are ready:
        - Use Bash from wiki_clone/ to:
            git add .
            git commit -m "Update wiki"
            git push

        RULES
        - You may READ from the whole project directory and wiki_clone/.
        - You may WRITE only to the three wiki pages inside wiki_clone/.
        - Never use Bash to inspect or edit files; only use it for git commands.
        - Keep documentation clear, concise, and in GitHub Wiki style.
        """

3. CLI के लिए रंग हैंडलिंग

यह CLI आउटपुट को बेहतर बनाता है, लेकिन colorama इंस्टॉल न होने पर भी स्क्रिप्ट काम करती है।

• रंगीन टेक्स्ट के लिए colorama का उपयोग करने की कोशिश करता है।
• MockColors पर फॉलबैक—स्क्रिप्ट बिना रंगों के भी क्रैश हुए बिना चलती है।

try:
    from colorama import Fore, Style, init

    init()
except ImportError:

    class MockColors:
        def __getattr__(self, name):
            return ""

    Fore = Style = MockColors()

4. सत्र आँकड़ों को ट्रैक करना

कॉस्ट, टर्न्स, और अवधि को ट्रैक करने के लिए एक छोटी-सी dataclass।

• total_cost: Claude SDK से $ लागत का योग।
• total_turns: आपने भेजे गए उपयोगकर्ता क्वेरी की संख्या।
• duration_ms: मिलीसेकंड में संचित अवधि।

@dataclass
class SessionStats:
    total_cost: float = 0.0
    total_turns: int = 0
    duration_ms: int = 0

5. एजेंट विकल्प बनाना

अगला, हम ClaudeAgentOptions ऑब्जेक्ट बनाएंगे और अपने MCP सर्वर से कनेक्ट करेंगे। नीचे दिया गया फ़ंक्शन आवश्यक एन्वायरनमेंट वेरिएबल्स को मान्य करता है, GitHub MCP सर्वर उपलब्ध होने पर उसे कॉन्फ़िगर करता है, और उन टूल्स को सीमित करता है जिन्हें एजेंट उपयोग कर सकता है।

हमने जानबूझकर allowed_tools को सीमित किया है ताकि Opus 4.5: Bash का उपयोग Git ऑपरेशंस के लिए करे, GitHub MCP सर्वर को कॉल करके रिपॉज़िटरी कंटेंट्स का निरीक्षण कर सके, और लोकल Markdown फ़ाइलों पर काम करने व उन्हें मान्य करने के लिए Read/Write (साथ में Glob और Grep) का उपयोग कर सके।

def create_agent_options() -> ClaudeAgentOptions:
    """Validates env vars and configures the agent options."""
    anthropic_key = os.getenv("ANTHROPIC_API_KEY")
    github_pat = os.getenv("GITHUB_PAT")

    if not anthropic_key:
        print(
            f"{Fore.RED}Error: ANTHROPIC_API_KEY environment variable is required.{Style.RESET_ALL}"
        )
        sys.exit(1)

    # Configure MCP servers
    mcp_servers: Dict[str, McpSdkServerConfig] = {}
    if github_pat:
        mcp_servers["github"] = {
            "type": "http",
            "url": "https://api.githubcopilot.com/mcp/",
            "headers": {"Authorization": f"Bearer {github_pat}"},
        }

    return ClaudeAgentOptions(
        model="claude-opus-4-5",
        system_prompt=SYSTEM_PROMPT,
        mcp_servers=mcp_servers,
        permission_mode="bypassPermissions",
        allowed_tools=[
            "Read",
            "Write",
            "Glob",
            "Grep",
            "Bash",
            "mcp__github__*",
        ],
    )

6. स्ट्रीमिंग प्रतिक्रिया को प्रोसेस करना

यह फ़ंक्शन स्ट्रीम को सुनता है और टेक्स्ट, टूल उपयोग, और टूल आउटपुट्स प्रिंट करता है।

• client.receive_response() को एक असिंक स्ट्रीम की तरह उपयोग करता है।
• असिस्टेंट का टेक्स्ट आते ही प्रिंट करता है।
• जब कोई टूल इनवोक होता है → [Tool Use: ...] प्रिंट करता है।
• जब टूल आउटपुट देता है → छोटा, सिंगल-लाइन प्रीव्यू ट्रंकेट कर प्रिंट करता है।
• जब ResultMessage आता है → SessionStats को कॉस्ट + अवधि से अपडेट करता है।

async def process_response_stream(client: ClaudeSDKClient, stats: SessionStats):
    """Handles the stream of messages from the agent."""
    async for message in client.receive_response():
        # 1. Handle Assistant Content (Text & Tool Requests)
        if isinstance(message, AssistantMessage):
            for block in message.content:
                if isinstance(block, TextBlock):
                    print(block.text, end="", flush=True)
                elif isinstance(block, ToolUseBlock):
                    print(f"\n{Fore.CYAN}[Tool Use: {block.name}]{Style.RESET_ALL}")

        # 2. Handle Tool Results (Outputs)
        if hasattr(message, "content") and isinstance(message.content, list):
            for block in message.content:
                if isinstance(block, ToolResultBlock):
                    # Truncate output for cleaner CLI
                    raw_output = str(block.content)
                    clean_output = raw_output.replace("\n", " ")
                    short_output = (
                        clean_output[:200] + "..."
                        if len(clean_output) > 200
                        else clean_output
                    )
                    print(
                        f"{Fore.YELLOW}  -> [Output]: {short_output}{Style.RESET_ALL}"
                    )

        # 3. Handle Result Metrics (Cost & Usage)
        if isinstance(message, ResultMessage):
            if message.total_cost_usd:
                stats.total_cost += message.total_cost_usd
            if message.duration_ms:
                stats.duration_ms += message.duration_ms

7. अंत में एक सारांश प्रिंट करना

CLI ऐप के लिए सत्र-समाप्ति आँकड़े—टर्न्स, अवधि, और डॉलर में लागत दिखाते हैं।

• duration_ms को सेकंड में बदलता है।
• कुल लागत को 4 दशमलव में फॉर्मैट कर दिखाता है।

def print_summary(stats: SessionStats):
    """Prints the final session statistics."""
    print(f"\n\n{Fore.GREEN}=== Session Summary ==={Style.RESET_ALL}")
    print(f"Total Turns:   {stats.total_turns}")
    print(f"Duration:      {stats.duration_ms / 1000:.2f}s")
    print(f"Total Cost:    ${stats.total_cost:.4f}")
    print(f"{Fore.GREEN}======================={Style.RESET_ALL}")

8. मुख्य असिंक फ़ंक्शन

यह ऐप का मुख्य कंट्रोल फ्लो है: सेटअप संभालता है, सर्विसेज़ से कनेक्ट करता है, यूज़र इनपुट पढ़ता है, और क्वेरी भेजता है। फ़ंक्शन create_agent_options() को कॉल करता है और आँकड़े इनिशियलाइज़ करता है। यह एक परिचयात्मक बैनर प्रिंट करता है और बताता है कि कौन-से MCP सर्वर सक्षम हैं। यह असिंक्रोनस कॉन्टेक्स्ट का उपयोग करके एक ClaudeSDKClient भी बनाता है।

एप्लिकेशन एक सरल REPL (Read-Eval-Print Loop) चलाता है:

1. एप्लिकेशन छोड़ने के लिए 'exit' या 'quit' टाइप करें।
2. हर वैध क्वेरी stats.total_turns को 1 से बढ़ा देती है।
3. await client.query(user_input) उपयोगकर्ता का संदेश भेजता है।
4. await process_response_stream(...) स्ट्रीम्ड परिणाम प्रिंट करता है।
5. किसी भी अपवाद को पकड़ा जाता है और लाल रंग में त्रुटि संदेश दिखता है।
6. अंत में, फ़ंक्शन हमेशा print_summary(stats) को कॉल करता है।

async def main():
    options = create_agent_options()
    stats = SessionStats()

    # Welcome message
    print(f"{Fore.GREEN}=== GitHub Wiki AI Agent (Auto-Mode) ==={Style.RESET_ALL}")
    print(
        f"MCP Servers: {', '.join(options.mcp_servers.keys()) if options.mcp_servers else 'None'}"
    )
    print("Ask me to help with a GitHub wiki by mentioning the repository URL!")
    print("Type 'exit' to quit.\n")

    async with ClaudeSDKClient(options=options) as client:
        try:
            await client.connect()

            while True:
                try:
                    user_input = input(f"\n{Fore.BLUE}>> {Style.RESET_ALL}").strip()
                except EOFError:
                    break

                if not user_input:
                    continue

                if user_input.lower() in ["exit", "quit"]:
                    break

                stats.total_turns += 1

                # Send query
                await client.query(user_input)
                print()  # Spacer

                # Process response stream using helper function
                await process_response_stream(client, stats)

        except Exception as e:
            print(f"\n{Fore.RED}Session Error: {e}{Style.RESET_ALL}")
        finally:
            print_summary(stats)

9. स्क्रिप्ट एंट्री पॉइंट

अंत में, हम स्क्रिप्ट का एंट्री पॉइंट परिभाषित करते हैं ताकि फ़ाइल को सीधे चलाने पर CLI रन हो। नीचे दिया ब्लॉक मुख्य असिंक लूप शुरू करता है और क्लीन शटडाउन हैंडल करता है:

if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        print("\nSession interrupted.")
        sys.exit(0)

ऑटो विकि एजेंट का परीक्षण

सब कुछ इंस्टॉल हो जाने के बाद, CLI चैट ऐप शुरू करें, और सुनिश्चित करें कि आपका Claude Code CLI ऐप काम कर रहा है:

python gh_wiki_cli.py

अब आप एजेंट के साथ एक चैट इंटरफ़ेस की तरह बातचीत कर सकते हैं। सामान्य प्रश्न पूछें या सीधे इसे अपनी रिपॉज़िटरी के लिए विकि बनाने को कहें:

create the github wiki for https://github.com/kingabzpro/ECom-Intel

यदि उपयोगकर्ता विकि बनाने के लिए कहता है, तो एजेंट स्वतः ये कार्य करता है:

1. विकि क्लोनिंग: एक wiki_clone/ फ़ोल्डर बनाता या पुन: उपयोग करता है और नवीनतम विकि कंटेंट खींचता है।
2. रिपॉज़िटरी निरीक्षण: MCP टूल्स का उपयोग करके GitHub रिपॉज़िटरी से प्रमुख फ़ाइलें पढ़ता है। 
3. पेज जनरेशन: स्वतः ड्राफ्ट तैयार करता है और पेज लिखता है, जैसे:
• Home.md
• Getting-Started.md
• Architecture-and-Tools.md
4. कमिट और पुश करना: एजेंट नए पेजों को स्टेज करता है, कमिट करता है, और अपडेट्स पुश करता है: <your-repo>.wiki.git
5. सफल आउटपुट उदाहरण: पूरा होने पर, आपको एक स्पष्ट कन्फर्मेशन संदेश दिखेगा। और विकि यहां लाइव होगी: https://github.com/kingabzpro/ECom-Intel/wiki

मैं सचमुच प्रभावित हुआ/हुई कि एजेंट ने कितनी अच्छी तरह से डेमो इमेजेज़, चार्ट्स, और अन्य प्रमुख जानकारी इकट्ठा की, और फिर विकि के लिए एक सुसंगत होम पेज तैयार किया।

अब विकि में एक उचित विषय-सूची, असिस्टेंट और टूल्स की व्याख्याएं, और स्पष्ट “गेटिंग स्टार्टेड” निर्देश शामिल हैं।

रन के अंत में, सत्र सारांश ने दिखाया कि यह एकल सत्र लगभग 1 USD का पड़ा—तीन-पेज की विकि बनाने के लिए यह काफ़ी महंगा है। यदि रिपॉज़िटरी बड़ी होती और हमें, उदाहरण के लिए, 12-पेज की विकि चाहिए होती, तो लागत काफ़ी बढ़ जाती।

=== Session Summary ===
Total Turns:   1
Duration:      282.99s
Total Cost:    $0.9047
=======================

दूसरे परीक्षण में, मैंने एजेंट से एक और रिपॉज़िटरी के लिए विकि बनाने को कहा:

create the github wiki for https://github.com/kingabzpro/Issue-Analyzer

परिणाम और भी बेहतर था। जेनरेटेड विकि, https://github.com/kingabzpro/Issue-Analyzer/wiki पर उपलब्ध, अब उचित डॉक्यूमेंटेशन शामिल करती है जो बताती है कि प्रोजेक्ट क्या करता है और कैसे शुरू करें। 

इसमें अच्छी तरह संरचित टेबल्स, एक आर्किटेक्चर डायग्राम, और अन्य मुख्य सेक्शन शामिल हैं, जो आपको पूरे प्रोजेक्ट को लगभग पांच मिनट में समझने देते हैं—कोड में दिनों बिताने के बजाय।

अंतिम विचार

जब मैंने पहली बार सुना कि Opus 4.5 को दुनिया का सर्वश्रेष्ठ कोडिंग और एजेंटिक मॉडल बताया जा रहा है, तो मैं सचमुच उत्साहित था/थी, खासकर क्योंकि इसकी कीमत Sonnet मॉडलों के समान है। 

हालांकि, जब एहसास हुआ कि थोड़ा-सा प्रयोग और एक छोटा एप्लिकेशन बनाने में API उपयोग पर लगभग $15 लग गए, तो उत्साह कम हो गया।

Opus 4.5 शक्तिशाली है लेकिन महंगा भी। मैंने वही वर्कफ़्लो Haiku और Sonnet का उपयोग करके दोहराने की भी कोशिश की, लेकिन इस तरह के एजेंटिक, डॉक्यूमेंटेशन-प्रधान कार्य के लिए अनुभव स्पष्ट रूप से कमतर था। 

दोनों बार-बार Bash टूल्स का सहारा लेते रहे, जबकि मैंने स्पष्ट रूप से GitHub फ़ाइलें पढ़ने के लिए MCP टूल्स उपयोग करने को कहा था। इसके अलावा, वे अक्सर समस्याओं को हल करने के लिए अधिक लंबा, कम प्रत्यक्ष रास्ता अपनाते रहे।

यदि आप सटीकता, विश्वसनीयता, और उच्च-गुणवत्ता वाले कोड और डॉक्यूमेंटेशन जनरेशन को प्राथमिकता देते हैं, तो Opus 4.5 निश्चित रूप से विचार करने योग्य है। 

हालांकि, यदि आपका उपयोग मामला कम क्रिटिकल है या आप लागत के प्रति बहुत संवेदनशील हैं, तो आप Sonnet या और भी सस्ते ओपन सोर्स मॉडलों के साथ रहना चाहेंगे। बड़े रिपॉज़िटरीज़ पर मल्टी-स्टेप, एजेंटिक वर्कफ़्लो के लिए Opus 4.5 की लागत तेज़ी से बढ़ सकती है।

यदि आप प्रोजेक्ट में रुचि रखते हैं, तो आप यहां पूरा सोर्स कोड पा सकते हैं, जिसे आप क्लोन कर के लोकली चला सकते हैं: kingabzpro/GitHub-Wiki-Agent।

यदि आप AI एजेंट्स बनाते रहने के इच्छुक हैं, तो मैं Multi-Agent Systems with LangGraph कोर्स देखने की सलाह देता/देती हूं।