Codex CLI MCP ट्यूटोरियल: एक पोर्टफोलियो डैशबोर्ड एजेंट बनाना

आपने अब तक शायद गौर किया होगा कि AI कोडिंग एजेंट जटिल फ़ंक्शंस लिखने या पेचीदा त्रुटियों को डिबग करने में बेहद उपयोगी होते हैं। लेकिन वे अक्सर एक दीवार से टकरा जाते हैं—जैसे ही आपको ऐसी जानकारी चाहिए होती है जो आपके प्रोजेक्ट फ़ाइलों के अंदर मौजूद न हो, उनकी उपयोगिता घटने लगती है। 

कल्पना कीजिए कि आपका कोडिंग एजेंट उस वातावरण से बाहर निकलकर लाइव डेटा ला सके, मौजूदा डॉक्यूमेंटेशन देख सके, या आपकी ओर से अलग-अलग टूल्स का इस्तेमाल कर सके। तभी ये एजेंट वास्तव में कहीं अधिक शक्तिशाली बनते हैं।

इस ट्यूटोरियल में, मैं आपको ठीक-ठीक बताऊंगा कि Codex CLI और Model Context Protocol यानी MCP का उपयोग करके यह कैसे किया जाए। हम देखेंगे कि Codex CLI और MCP साथ में कैसे काम करते हैं, लाइव स्टॉक डेटा से एक फ़ाइनेंस डैशबोर्ड प्रोजेक्ट शून्य से बनाएंगे, मल्टी-एजेंट पैटर्न कवर करेंगे, और सुरक्षा की सर्वोत्तम प्रक्रियाओं पर चर्चा करेंगे।

इससे अधिकतम लाभ लेने के लिए, मैं आपको साथ-साथ कदम बढ़ाने के लिए प्रोत्साहित करता हूँ। एक नया Next.js प्रोजेक्ट बनाएं, यह सुनिश्चित करें कि आपके पास Codex CLI की कार्यशील इंस्टॉलेशन है, और Alpha Vantage से एक निःशुल्क API कुंजी प्राप्त करें ताकि हम तैयार हों।

यदि आप एजेंटिक AI में नए हैं, तो मैं हमारे AI Agent Fundamentals स्किल ट्रैक में नामांकन की कड़ी सिफारिश करता हूँ।

Codex CLI MCP के मूल सिद्धांत

कोडिंग शुरू करने से पहले, हमें उन टूल्स को समझना होगा जिनका हम उपयोग कर रहे हैं। आइए स्पष्ट करें कि MCP क्या है और Codex CLI इसे कैसे उपयोग करता है।

MCP क्या है?

तो, MCP क्या है? इसका अर्थ है Model Context Protocol। यह Anthropic द्वारा पेश किया गया एक ओपन स्टैंडर्ड है जो यह मानकीकृत करता है कि AI सिस्टम बाहरी टूल्स और डेटा स्रोतों से कैसे जुड़ते हैं। तकनीकी रूप से, यह STDIO (स्टैंडर्ड इनपुट/आउटपुट) या HTTP के ऊपर JSON-RPC 2.0 के जरिए काम करता है।

स्रोत: truefoundry

यह इसलिए महत्वपूर्ण है क्योंकि यह एक बड़े मसले—जिसे हम “इंटीग्रेशन नाइटमेयर” कह सकते हैं—का व्यावहारिक समाधान देता है: अतीत में, यदि आप किसी LLM को किसी खास डेटाबेस या टूल से जोड़ना चाहते थे, तो आपको अक्सर उसी जोड़ी के लिए कस्टम कनेक्टर बनाना पड़ता था। यह गड़बड़, मेंटेन करना कठिन और कम स्केलेबल होता था। 

MCP के साथ, अब हमारे पास सभी LLM टूल कनेक्शनों के लिए एक एकीकृत प्रोटोकॉल है। यह कस्टम इंटीग्रेशन को एक मानक इंटरफ़ेस से बदलकर परिदृश्य को सरल बनाता है।

यदि आप आंतरिक कार्यप्रणाली समझना चाहते हैं, तो यह MCP सर्वर और क्लाइंट को शून्य से बनाने पर वॉकथ्रू एक अच्छा साथी है।

Codex CLI क्या है?

अब, Codex CLI की बात करते हैं। यह OpenAI का हल्का, टर्मिनल-आधारित कोडिंग एजेंट है। अन्य AI कोडिंग टूल्स जैसे Claude Code या Cursor की तरह, यह आपके पूरे प्रोजेक्ट संदर्भ को समझने के लिए डिज़ाइन किया गया है—सिर्फ वर्तमान में खुले फ़ाइल तक सीमित नहीं।

यह वास्तव में सब कुछ एक जगह जोड़ता है—कुशल कोड इंडेक्सिंग, बातचीत का इतिहास, और वास्तविक कमांड निष्पादन—एक ही टेक्स्ट यूज़र इंटरफ़ेस (TUI) में। इसका लगभग सारा व्यवहार एक config.toml फ़ाइल को एडिट करके नियंत्रित और कस्टमाइज़ किया जा सकता है, जिससे इसे मैनेज करना आसान हो जाता है।

Codex MCP को कैसे लागू करता है

MCP इम्प्लीमेंटेशन की बात करें, तो Codex STDIO सर्वर और Streamable HTTP सर्वर दोनों को सपोर्ट करता है:

• STDIO सर्वर लोकल प्रोसेस के रूप में चलते हैं। आप उन्हें ऐसे समझें जैसे आपकी मशीन पर सीधे विशिष्ट कमांड और आर्ग्युमेंट्स चल रहे हों।
• Streamable HTTP सर्वर एक URL के जरिए रिमोटली कनेक्ट होते हैं और एक्सेस के लिए वैकल्पिक रूप से बेयरर टोकन या OAuth ऑथेंटिकेशन सपोर्ट करते हैं।

एक बहुत ही सुविधाजनक बात यह है कि Codex CLI और IDE एक्सटेंशन वास्तव में एक ही config.toml फ़ाइल साझा करते हैं। यानी चाहे आप टर्मिनल में काम कर रहे हों या एडिटर में—आपको एक जैसा MCP टूलिंग मिलता है; आपको दो बार कॉन्फ़िगर नहीं करना पड़ता, जिससे काफी समय बचता है। 

Codex ऑथेंटिकेशन भी अच्छे से संभालता है, codex mcp login <server-name> कमांड के जरिए OAuth सपोर्ट करता है। यह आपको enabled_tools या disabled_tools सेटिंग्स के माध्यम से विशिष्ट टूल्स फ़िल्टर करने देकर एजेंट की क्षमताओं पर सूक्ष्म नियंत्रण भी देता है।

Codex CLI MCP सेटअप

अब जबकि हमने थ्योरी कवर कर ली है, अब हाथ गंदे करने का समय है और सेटअप करते हैं। इस खंड में, हम देखेंगे कि अपने MCP सर्वर कैसे कॉन्फ़िगर करें ताकि वे आपके लिए काम करने को तैयार हों।

पूर्वापेक्षाएँ

Codex को MCP और Agents SDK से जोड़ने से पहले, सुनिश्चित करें कि निम्नलिखित तैयार हैं:

• इस मशीन पर Codex CLI इंस्टॉल है। आप टर्मिनल खोलकर npm install -g @openai/codex चलाकर इसे ग्लोबली इंस्टॉल कर सकते हैं। codex --version चलाकर इंस्टॉलेशन की पुष्टि करें।

• इस मशीन पर Codex ऑथेंटिकेटेड है। एक बार codex login (या हेडलेस वातावरण में codex login --device-auth) चलाएँ, और सत्यापित करें कि टर्मिनल में codex सामान्य रूप से काम कर रहा है। 

• मल्टी-एजेंट वर्कफ़्लो के लिए आपको OpenAI API कुंजी भी चाहिए। इसे OpenAI कंसोल में प्राप्त करें, और अपने शेल में export OPENAI_API_KEY="sk-..." से सेट करें।

• बाहरी टूल्स के लिए environment variables सेट हों। उदाहरण के लिए, Alpha Vantage आपका मार्केट डेटा की ALPHA_VANTAGE_KEY से पढ़ता है, जिसे उदाहरण चलाने से पहले इसी तरह एक्सपोर्ट करना चाहिए।

AlphaVantage API कुंजी प्राप्त करने के लिए:

1. AlphaVantage सपोर्ट पेज पर जाएँ।
2. ​संक्षिप्त पंजीकरण फ़ॉर्म भरें (संस्था, भूमिका और ईमेल)।
3. आपकी API कुंजी तुरंत प्रदर्शित हो जाएगी। इसे कॉपी कर सुरक्षित रखें।

मुफ़्त टियर प्रति दिन अधिकतम 25 API अनुरोधों की अनुमति देता है। भारी उपयोग के लिए, Alpha Vantage प्रीमियम प्लान प्रदान करता है।

CLI के माध्यम से MCP सर्वर जोड़ना

अगला, हम कमांड-लाइन इंटरफ़ेस और codex mcp add कमांड का उपयोग करके नया सर्वर जोड़ेंगे। इस तरह, आपको कॉन्फ़िगरेशन फ़ाइलों से हाथ से छेड़छाड़ नहीं करनी पड़ेगी, और Codex आपके लिए अधिकतर काम कर देगा।

उदाहरण के लिए, यदि आप डॉक्यूमेंटेशन लुकअप में मदद करने के लिए सर्वर जोड़ना चाहते हैं, तो आप Context7 MCP सर्वर का उपयोग कर सकते हैं। इसे इंस्टॉल करने के लिए, अपने टर्मिनल में निम्न कमांड चलाएँ:

codex mcp add context7 -- npx -y @upstash/context7-mcp

config.toml के माध्यम से MCP सर्वर जोड़ना

जहाँ CLI कमांड्स जल्दी शुरुआत के लिए बेहतरीन हैं, वहीं कभी-कभी आपको थोड़ा अधिक नियंत्रण चाहिए होता है, या आप ठीक-ठीक देखना पसंद करते हैं कि अंदर क्या हो रहा है। उस स्थिति में, आप कॉन्फ़िगरेशन फ़ाइल सीधे संपादित कर सकते हैं।

यह जानना महत्वपूर्ण है कि यह कॉन्फ़िगरेशन वास्तव में दो जगहों पर रहता है, और उनका स्कोप अलग-अलग है:

• ग्लोबल कॉन्फ़िगरेशन फ़ाइल ~/.codex/config.toml पर स्थित होती है, जो आपके हर प्रोजेक्ट पर लागू होती है

• प्रोजेक्ट-स्कोप्ड कॉन्फ़िगरेशन फ़ाइल आपके विशेष प्रोजेक्ट फ़ोल्डर के अंदर .codex/config.toml में होती है। आम तौर पर, टकराव होने पर प्रोजेक्ट-स्कोप्ड सेटिंग्स ग्लोबल सेटिंग्स को ओवरराइड करती हैं।

सभी MCP सर्वर समर्पित CLI इंस्टॉल कमांड के साथ नहीं आते। उन मामलों में, आप ~/.codex/config.toml में सीधे कमांड और आर्ग्युमेंट्स निर्दिष्ट करके उन्हें कॉन्फ़िगर करते हैं जिनकी Codex को सर्वर प्रोसेस लॉन्च करने के लिए आवश्यकता होती है। इससे आपको इस बात पर पूरा नियंत्रण मिलता है कि सर्वर कैसे शुरू होता है—चाहे वह STDIO के माध्यम से लोकली चले या HTTP के माध्यम से रिमोटली कनेक्ट हो।

AlphaVantage MCP सर्वर उनमें से एक है। config.toml खोलें और निम्न ब्लॉक जोड़ें:

[mcp_servers.alphavantage]
command = "uvx"
args = ["av-mcp", "<your-key>”]

अस्वीकरण: वास्तविक प्रोजेक्ट्स के लिए API कुंजी को सीधे config.toml में हार्डकोड करना अनुशंसित नहीं है। किसी भी ऐसे प्रोजेक्ट में इससे बचें जो वर्शन-कंट्रोल्ड हो (जैसे GitHub पर), अन्य डेवलपर्स के साथ साझा हो, या सर्वर पर डिप्लॉय हो, क्योंकि जिसे भी इस फ़ाइल तक पहुंच होगी, वह आपकी कुंजी पढ़कर दुरुपयोग कर सकता है। इस ट्यूटोरियल के लिए यह स्वीकार्य है क्योंकि config.toml आपके होम डायरेक्टरी (~/.codex/) में रहता है और आपकी मशीन के लिए निजी है।

ब्लॉक में जोड़ने के लिए एक उपयोगी पंक्ति है startup_timeout_sec=30, जो डिफ़ॉल्ट 10-सेकंड टाइमआउट को ओवरराइड करती है और कनेक्शन को स्थापित होने के लिए पर्याप्त समय देती है।

MCP सर्वर प्रबंधन

एक बार जब आपने कुछ सर्वर सेट कर लिए, तो आपको उन्हें मैनेज करना आना चाहिए। Codex आपको चीज़ों को व्यवस्थित रखने के लिए कमांड्स का एक सेट देता है।

यदि आप देखना चाहते हैं कि अभी क्या इंस्टॉल है, तो आप बस codex mcp list चला सकते हैं। यदि आपको किसी सर्वर का विशिष्ट विवरण जाँचना है, जैसे कि हमने अभी Alpha Vantage जोड़ा, तो codex mcp get alphavantage चलाएँ। और, बेशक, यदि आप तय करते हैं कि अब आपको किसी सर्वर की आवश्यकता नहीं है—मान लें Context7—तो आप codex mcp remove context7 चलाकर उसे हटा सकते हैं।

अंत में, जब आप किसी सक्रिय Codex सत्र के अंदर काम कर रहे हों, तो आप सत्यापित कर सकते हैं कि सब कुछ सही चल रहा है। आप चैट इंटरफ़ेस में सीधे /mcp टाइप करें, और यह आपके जुड़े टूल्स की स्थिति दिखाएगा। इसमें alphavantage और context7 दोनों दिखने चाहिए, प्रत्येक के साथ Status: enabled।

Codex और MCP के साथ एक स्टॉक पोर्टफोलियो रिस्क डैशबोर्ड बनाना

थ्योरी उपयोगी है, लेकिन सीखने का सबसे अच्छा तरीका कुछ वास्तविक बनाना है। इस सेक्शन में, हम Codex और MCP का उपयोग करके वास्तविक मार्केट डेटा फ़ेच करेंगे और रिस्क मेट्रिक्स की गणना करेंगे, तथा शून्य से एक फ़ंक्शनल स्टॉक पोर्टफोलियो रिस्क डैशबोर्ड बनाएंगे।

डैशबोर्ड को दिखाने के लिए प्रोजेक्ट TypeScript (एक JavaScript-आधारित प्रोग्रामिंग भाषा) का उपयोग करता है। अलग-अलग स्तरों के लिए रिफ्रेशर हेतु, मैं हमारे TypeScript इंटरव्यू प्रश्न गाइड की सलाह देता हूँ।

प्रोजेक्ट सेटअप

प्रोजेक्ट सेटअप करने के लिए नीचे दिए गए चरणों का पालन करें:

1. प्रोजेक्ट को इनिशियलाइज़ करें: अपने टर्मिनल में मानक Next.js निर्माण कमांड चलाएँ: npx create-next-app@latest portfolio-dashboard --typescript

2. मानक कॉन्फ़िगरेशन सुनिश्चित करने के लिए डिफ़ॉल्ट प्रॉम्प्ट स्वीकार करें

3. अपने नए प्रोजेक्ट फ़ोल्डर में डायरेक्टरी पर जाएँ: cd portfolio-dashboard

4. UI कॉम्पोनेन्ट्स के लिए एक सबडायरेक्टरी बनाकर कॉम्पोनेन्ट संरचना तैयार करें: mkdir components

5. components सबफ़ोल्डर में .tsx फ़ाइल के रूप में पोर्टफोलियो कार्ड एलिमेंट बनाएं: components/PortfolioCard.tsx

यह कॉम्पोनेन्ट एक PortfolioCard परिभाषित करता है जो एक स्टाइल्ड कार्ड रेंडर करता है और नकली स्टॉक पोज़िशन्स (AAPL और TSLA) की सूची दिखाता है, जिसमें प्रत्येक स्टॉक का सिंबल, शेयरों की संख्या और मौजूदा कीमत प्रदर्शित होती है। यह लेआउट और स्टाइलिंग के लिए Tailwind CSS क्लासेस का उपयोग करता है, जिसमें सफेद कार्ड कंटेनर और एमराल्ड-ग्रीन मूल्य फ़ॉर्मैटिंग है। यह कुछ इस तरह दिखना चाहिए:

// components/PortfolioCard.tsx
import React from 'react';

type Position = {
  symbol: string;
  shares: number;
  price: number;
};

const mockPositions: Position[] = [
  { symbol: 'AAPL', shares: 10, price: 150.00 },
  { symbol: 'TSLA', shares: 5, price: 900.00 },
];

export const PortfolioCard = () => {
  return (
    // Added text-slate-900 to ensure visibility on the white background
    <div className="p-6 border border-slate-200 rounded-xl shadow-sm bg-white text-slate-900">
      <h2 className="text-xl font-bold mb-4">My Portfolio</h2>
      <ul className="divide-y divide-slate-100">
        {mockPositions.map((pos) => (
          <li key={pos.symbol} className="flex justify-between py-3">
            <div className="flex flex-col">
              <span className="font-bold text-slate-800">{pos.symbol}</span>
              <span className="text-sm text-slate-500">{pos.shares} shares</span>
            </div>
            <span className="font-mono font-semibold text-emerald-600">
              ${pos.price.toFixed(2)}
            </span>
          </li>
        ))}
      </ul>
    </div>
  );
};

उस फ़ाइल को सेव करने के बाद, अपने मुख्य app/page.tsx फ़ाइल के अंदर <PortfolioCard/> को इम्पोर्ट करें और उपयोग करें ताकि आप इसे ब्राउज़र में देख सकें:

// app/page.tsx
import { PortfolioCard } from "../components/PortfolioCard";

export default function Page() {
  return (
    <main className="min-h-screen flex items-center justify-center bg-slate-50">
      <PortfolioCard />
    </main>
  );
}

जब आप अब npm run dev चलाएँगे, तो आपको अपने ब्राउज़र में कुछ इस तरह का आउटपुट दिखना चाहिए:

AI के साथ कोडिंग शुरू करने से पहले, हमें सुनिश्चित करना है कि हमारे एजेंट सक्रिय हों। npm run dev के साथ टर्मिनल चलने दें। एक नया टर्मिनल विंडो खोलें:

1. यदि आपने पहले से नहीं किया है, तो पहले बताए गए MCP कॉन्फ़िगरेशन कमांड्स चलाएँ

2. अपनी API कुंजी एक्सपोर्ट करें: ALPHA_VANTAGE_KEY=”<your-key>” एक्सपोर्ट करें

3. उसी टर्मिनल विंडो में, codex चलाकर Codex एजेंट शुरू करें

Sharpe रेश्यो फ़ीचर लागू करना

पहला फ़ीचर जो हम गणना करेंगे, वह Sharpe रेश्यो है—निवेश के जोखिम-समायोजित रिटर्न का एक अहम मेट्रिक। आमतौर पर, फ़ॉर्मूला खोजना और इसे निकालने के लिए सही लाइब्रेरी ढूँढना थोड़ा उबाऊ हो सकता है। यह काम हम Codex को सौंपेंगे।

अपने Codex टर्मिनल सत्र में, निम्न प्रॉम्प्ट टाइप करें:

"PortfolioCard.tsx में प्रत्येक पोज़िशन के लिए Sharpe रेश्यो कैलकुलेशन जोड़ें। ज़रूरत हो तो Context7 का उपयोग करके फ़ंक्शन सिग्नेचर जाँचें।"

आप देखेंगे कि Codex सक्रिय हो जाएगा। पहले, यह सुनिश्चित करने के लिए कि सही इनपुट्स का उपयोग हो, वह टेक्निकल एनालिसिस लाइब्रेरी (ta-lib या JavaScript समकक्ष) का डॉक्यूमेंटेशन देखने हेतु Context7 टूल का उपयोग कर सकता है। इसके बाद यह स्वचालित रूप से आपकी PortfolioCard.tsx फ़ाइल में बदलाव करेगा।

संभावना है कि यह mockPositions का विस्तार करेगा और रेश्यो निकालने के लिए एक हेल्पर फ़ंक्शन जोड़ेगा, जो कुछ इस तरह दिखेगा:

function calculateSharpe(prices: number[]) {
  // Codex implements the logic here using standard deviation and mean returns
  // resulting in a return value like 1.23
}

और यह नया मेट्रिक रेंडर करने के लिए आपका JSX अपडेट करेगा:

<PortfolioCard sharpe={calculateSharpe(prices)}/>

जब आप अपने ब्राउज़र की जाँच करेंगे, तो आपको अब Sharpe रेश्यो (जैसे, 1.23) अपनी पोज़िशन्स के पास दिखना चाहिए, कुछ इस तरह:

वोलैटिलिटी अलर्ट्स जोड़ना

अब डैशबोर्ड को रिएक्टिव बनाते हैं और AlphaVantage के वास्तविक वित्तीय डेटा का उपयोग करते हैं। हम चाहते हैं कि यदि कोई स्टॉक बहुत अधिक अस्थिर हो रहा हो तो हमें अलर्ट मिले। हम “उच्च वोलैटिलिटी” को 7-दिन की वोलैटिलिटी 3% से अधिक के रूप में परिभाषित करेंगे।

Codex टर्मिनल में, यह प्रॉम्प्ट दर्ज करें:

"Alpha Vantage डेटा का उपयोग करके उन पोज़िशन्स को फ़्लैग करें जहाँ 7-दिन की वोलैटिलिटी > 2% हो। मेरी सूची में मौजूद सिंबल्स के लिए प्राइस हिस्ट्री फ़ेच करें।"

यहीं MCP चमकता है। Codex पहचान लेगा कि उसे बाहरी डेटा चाहिए। यह वास्तविक वर्ल्ड डेटा पॉइंट्स पाने के लिए alphavantage.get_price_history("AAPL") और alphavantage.get_price_history("TSLA") कॉल करेगा।

डेटा प्राप्त करने के बाद, यह उन कीमतों का मानक विचलन (स्टैंडर्ड डिविएशन) निकालने का लॉजिक लिखेगा। अंत में, यह आपके कॉम्पोनेन्ट की स्टाइलिंग भी अपडेट करेगा ताकि जोखिम को दृश्य रूप से फ़्लैग किया जा सके।

आप देखेंगे कि आपका PortfolioCard कोड कंडीशनल स्टाइलिंग शामिल करने के लिए अपडेट हो जाएगा। लॉजिक कुछ इस तरह दिख सकता है:

<li className={volatility > 2 ? "text-red-500 font-bold" : "text-green-500"}>
  {pos.symbol}: {volatility}%
</li>

यदि आप अपना रनिंग एप्लिकेशन देखें, तो आप AAPL को हरे (सुरक्षित) और TSLA को लाल (अस्थिर) रंग में देख सकते हैं—ये सब एजेंट द्वारा खींचे गए लाइव मार्केट डेटा पर आधारित होगा।

अंतिम आउटपुट कुछ ऐसा दिखना चाहिए:

आपका अंतिम UI ऊपर दर्शाए गए से थोड़ा अलग हो सकता है, यह इस पर निर्भर करता है कि Codex इसे कैसे स्ट्रक्चर करता है। बेशक, आप अपने प्रॉम्प्ट में अधिक सटीक होकर भी बता सकते हैं कि अंत परिणाम कैसा दिखना चाहिए।

यदि आप बड़े सिस्टम डिज़ाइन करना और हैंडऑफ़्स, टूल सीमाएँ और मूल्यांकन के बारे में सीखना चाहते हैं, तो मैं हमारे Building Scalable Agentic Systems कोर्स लेने की सलाह देता हूँ।

MCP सर्वर के रूप में Codex चलाना

अब तक, हम Codex का उपयोग मुख्य इंटरफ़ेस के रूप में कर रहे थे जो अन्य टूल्स को कॉल करता है। पर यहाँ चीज़ें वाकई दिलचस्प हो जाती हैं: Codex खुद भी MCP सर्वर के रूप में काम कर सकता है। 

इसका मतलब है कि आप Codex की शक्तिशाली फ़ाइल एडिटिंग और कमांड निष्पादन क्षमताओं को अन्य MCP क्लाइंट्स के लिए एक्सपोज़ कर सकते हैं, जिससे अन्य AI एजेंट्स अपने वर्कफ़्लो में Codex को एक टूल के रूप में इस्तेमाल कर पाएँगे। सबसे बड़ा फायदा यह है कि यह पैरेलल एक्ज़िक्यूशन सक्षम करता है। 

आप ऐसा वर्कफ़्लो डिज़ाइन कर सकते हैं जहाँ एक एजेंट आपके फ़्रंटएंड UI को बनाने के लिए Codex का उपयोग करे, जबकि एक अलग एजेंट Codex के किसी अलग इंस्टेंस का उपयोग कर आपका बैकएंड API लिखे। क्योंकि वे अलग-अलग प्रोसेसेस के रूप में चल रहे हैं, वे एक साथ काम कर सकते हैं—संभावित रूप से आपके डेवलपमेंट समय को आधा कर देते हैं।

Codex सर्वर मोड शुरू करना

Codex को इस मोड में डालने के लिए, हम एक विशेष कमांड का उपयोग करते हैं: codex mcp-server।

जब आप इसे चलाते हैं, तो Codex चैट इंटरफ़ेस की तरह बर्ताव करना बंद कर देता है और किसी अन्य प्रोग्राम से निर्देशों को सुनना शुरू कर देता है। यह अपनी क्षमताएँ स्टैंडर्ड इनपुट/आउटपुट (STDIO) चैनल के ऊपर एक्सपोज़ करता है।

इसे किसी जटिल सिस्टम में इंटीग्रेट करने की कोशिश करने से पहले, इसे टेस्ट करना हमेशा अच्छा विचार है ताकि पक्का हो जाए कि यह वाकई काम कर रहा है। Model Context Protocol टीम इसके लिए एक उपयोगी इंस्पेक्टर टूल देती है। आप अपने टर्मिनल में निम्न कमांड चलाकर एक वेब इंटरफ़ेस चालू कर सकते हैं जो आपकी लोकल Codex इंस्टेंस से जुड़ता है:

npx @modelcontextprotocol/inspector codex mcp-server

यह एक ब्राउज़र विंडो खोलेगा जहाँ आप Codex को मैन्युअली कमांड भेज सकते हैं और ठीक-ठीक देख सकते हैं कि वह कैसे जवाब देता है—डिबगिंग के लिए यह बहुत सहायक है। UI कुछ इस तरह दिखता है:

OpenAI Agents SDK इंटीग्रेशन

यदि आप Python डेवलपर हैं, तो आप OpenAI Agents SDK का उपयोग करके किसी कस्टम स्क्रिप्ट के भीतर Codex को ऑर्केस्ट्रेट करना चाहेंगे। यह आपको एक Python प्रोग्राम बनाने देता है जो Codex को विशिष्ट कोडिंग कार्यों के लिए “हायर” कर सके।

यहाँ एक त्वरित उदाहरण है कि आप इसे कैसे सेट करेंगे। आप MCPServerStdio का उपयोग Codex प्रोसेस लॉन्च करने के लिए करते हैं:

अपने Python वर्चुअल एनवायरनमेंट में openai-agents पैकेज इंस्टॉल करें:

pip install openai-agents

codex प्रोसेस सेटअप करने के लिए, orchestrator.py फ़ाइल बनाएँ और इसमें निम्न कोड लिखें:

from agents import Agent
from agents.mcp import MCPServerStdio

# initialize connection
codex_server = MCPServerStdio(
    name="Codex CLI",
    params={
        "command": "npx",
        "args": ["-y", "codex", "mcp-server"]
    },
    client_session_timeout_seconds=360000,
)
# create codex agent
agent = Agent(
    name="Lead Developer",
    mcp_servers=[codex_server]
)

इस सेटअप में, Codex MCP सर्वर दो मुख्य टूल्स एक्सपोज़ करता है: codex() और codex-reply()। इनके बीच का फ़र्क समझना ज़रूरी है, क्योंकि यही एजेंट को उसके काम के संदर्भ में बनाए रखता है।

• जब आप कोई बिल्कुल नया सत्र या टास्क शुरू करना चाहते हैं, तो codex() का उपयोग करें। 
• जब आप मौजूदा बातचीत जारी रखना चाहते हैं या अभी-अभी किए गए काम पर इटरेट करना चाहते हैं, तो codex-reply() का उपयोग करें। इसे सही बातचीत से अनुरोध मैप करने के लिए conversationId पैरामीटर चाहिए।

client_session_timeout_sessions वह अधिकतम समय है जब क्लाइंट संबंधित MCP STDIO सर्वर के साथ एक सत्र खुला रखता है। हम इसे Codex के लिए 360,000 सेकंड (100 घंटे) पर उदारता से रखते हैं ताकि लंबे वर्कफ़्लोज़ एक ही MCP सत्र को दोबारा उपयोग कर सकें और idle टाइमआउट से न टकराएँ।

कम्युनिटी रैपर्स

समुदाय ने भी इसे और आसान बनाने के लिए रैपर्स बनाए हैं। एक उल्लेखनीय प्रोजेक्ट है codex-mcp-wrapper रिपोज़िटरी (GitHub)। यह रैपर विशेष रूप से आपको Codex को अन्य वातावरणों—जैसे Claude Code—में इंटीग्रेट करने देता है।

Codex CLI MCP मल्टी-एजेंट फ़ाइनेंस पाइपलाइन का ऑर्केस्ट्रेशन

अब जब हम समझ गए हैं कि Codex को सर्वर की तरह कैसे चलाया जाए, आइए एक वास्तविक उपयोग-परिदृश्य देखें जहाँ यह शक्तिशाली बनता है। हम एक मल्टी-एजेंट पाइपलाइन का ऑर्केस्ट्रेशन करेंगे जिसमें कई AI एजेंट साथ मिलकर काम करते हैं, और एकल एजेंट की तुलना में हमारे फ़ाइनेंस डैशबोर्ड के अपग्रेड को काफ़ी तेज़ कर देते हैं।

यदि मल्टी-एजेंट डिज़ाइन अमूर्त लगता है, तो यहाँ सामान्य एजेंट आर्किटेक्चर्स का स्पष्ट विवरण है और यह कि मल्टी-एजेंट सेटअप्स वास्तव में कहाँ मदद करते हैं।

रिस्क और UI एजेंट्स का समन्वय

इस सेटअप में, हम वर्कफ़्लो मैनेज करने के लिए Python स्क्रिप्ट को ऑर्केस्ट्रेटर के रूप में उपयोग करते हैं। एक एजेंट से सबकुछ कराने के बजाय, हम दो विशेषज्ञ एजेंट्स स्पॉन करते हैं: 

• Codex-Risk, जो क्वांटिटेटिव एनालिसिस पर केंद्रित है
• Codex-UI, जो फ़्रंटएंड इम्प्लिमेंटेशन पर केंद्रित है

क्योंकि अब हम Agents SDK से एक हेडलेस MCP सर्वर के रूप में Codex चला रहे हैं, इसलिए सिर्फ़ इंटरैक्टिव Codex CLI ही नहीं, बल्कि SDK और Codex प्रोसेसेस—दोनों—को OpenAI के साथ ऑथेंटिकेट होना होगा। 

चीज़ों को सरल और भरोसेमंद रखने के लिए, ऑर्केस्ट्रेटर चलाने से पहले अपने वातावरण में OPENAI_API_KEY (या वैकल्पिक रूप से CODEX_API_KEY) सेट करें ताकि चेन का हर हिस्सा मॉडेल्स से बात कर सके। एक नए टर्मिनल में निम्न कमांड चलाएँ:

export OPENAI_API_KEY=<your-key>

हम एक async with ब्लॉक में दो स्वतंत्र Codex MCP सर्वर इनिशियलाइज़ करते हैं ताकि स्थिर, आइसोलेटेड कनेक्शन (प्रति एजेंट एक प्रोसेस) सुनिश्चित हों—यही उन्हें पैरेलल में चलाने में सक्षम बनाता है। यहाँ orchestrator.py नामक ऑर्केस्ट्रेशन स्क्रिप्ट है:

import os
import asyncio
from dotenv import load_dotenv
from agents import Agent, Runner
from agents.mcp import MCPServerStdio


load_dotenv()


async def main():
    async with MCPServerStdio(
        name="Codex-Risk-Server",
        params={
            "command": "npx",
            "args": ["-y", "codex", "mcp-server"],
            # Codex itself uses your existing auth (codex login / OPENAI_API_KEY)
            "env": {
                # pass through any env you already rely on inside Codex
                "OPENAI_API_KEY": os.getenv("OPENAI_API_KEY", ""),
                "CODEX_API_KEY": os.getenv("CODEX_API_KEY", ""),
            },
        },
        client_session_timeout_seconds=360000,
    ) as codex_risk_server, MCPServerStdio(
        name="Codex-UI-Server",
        params={
            "command": "npx",
            "args": ["-y", "codex", "mcp-server"],
            "env": {
                "OPENAI_API_KEY": os.getenv("OPENAI_API_KEY", ""),
                "CODEX_API_KEY": os.getenv("CODEX_API_KEY", ""),
            },
        },
        client_session_timeout_seconds=360000,
    ) as codex_ui_server:

        # 1. Define specialized agents (both just use the 'codex' tool)
        risk_agent = Agent(
            name="Codex-Risk",
            instructions=(
                "You are a quant analyst. Use the 'codex' tool to compute VaR and "
                "Sharpe ratio for all positions in the portfolio-dashboard project. "
                "Assume Alpha Vantage integration and volatility logic are already implemented "
                "in the code; reuse and extend that code instead of re-calling external APIs."
            ),
            mcp_servers=[codex_risk_server],
        )

        ui_agent = Agent(
            name="Codex-UI",
            instructions=(
                "You are a frontend developer. Use the 'codex' tool to update the UI in "
                "the portfolio-dashboard project. Your job is to add a VaR (95%) column "
                "to the RiskTable / PortfolioCard views, with clear red/green conditional styling."
            ),
            mcp_servers=[codex_ui_server],
        )

        # 2. Run Risk + UI agents concurrently
        risk_task = Runner.run(
            risk_agent,
            "Compute portfolio VaR (95%) for all positions and write the results into the codebase "
            "in a way that the UI can easily consume (e.g., exported constants or helper functions).",
        )
        ui_task = Runner.run(
            ui_agent,
            "Prepare or update the RiskTable / PortfolioCard components to display a VaR (95%) "
            "column, assuming the risk logic already exists in the project.",
        )

        risk_result, ui_result = await asyncio.gather(risk_task, ui_task)

        print("=== Codex-Risk result ===")
        print(risk_result.final_output)
        print("\n=== Codex-UI result ===")
        print(ui_result.final_output)

        # 3. Optional second pass: let UI agent consume the exact risk output
        followup_ui_result = await Runner.run(
            ui_agent,
            (
                "Now update the UI to wire in the actual VaR values. "
                f"Context from the risk agent: {risk_result.final_output}"
            ),
        )

        print("\n=== Codex-UI follow-up ===")
        print(followup_ui_result.final_output)


if __name__ == "__main__":
    asyncio.run(main())

उसी टर्मिनल विंडो में जिसमें आपने अपनी OpenAI API कुंजी सेट की है, ऑर्केस्ट्रेशन स्क्रिप्ट चलाएँ:

python orchestrator.py

ये एजेंट MCP के जरिए स्वतंत्र रूप से Alpha Vantage डॉक्यूमेंटेशन जाँचेंगे, ऐतिहासिक डेटा फ़ेच करेंगे, और आपके पोर्टफोलियो के लिए Value at Risk निकालने हेतु Python या TypeScript लॉजिक लिखेंगे।

दोनों Codex इंस्टेंस आवश्यक बदलाव कर लेने के बाद, आप npm run dev कमांड फिर चलाकर उन्हें ब्राउज़र में विज़ुअलाइज़ कर सकते हैं। यह कुछ इस तरह दिखेगा:

इन चिंताओं को अलग-अलग करके, हम एक ऐसी प्रक्रिया को—जो सामान्यतः 20 मिनट के आगे-पीछे चैट में लग सकती है—पूरी तरह स्वचालित पाइपलाइन में बदल देते हैं। रिस्क एजेंट गणित संभालता है, UI एजेंट इम्प्लिमेंटेशन संभालता है, और डैशबोर्ड कुछ ही सेकंड में अपडेट हो जाता है।

समानांतर कार्य निष्पादन

यहाँ वास्तविक जादू निष्पादन मॉडल में है। एक मानक चैट इंटरफ़ेस में, टूल कॉल्स अनुक्रमिक होते हैं; यानी डेटा फ़ेच होने का इंतज़ार करना पड़ता है, तभी आप चार्ट अपडेट कराने को कह सकते हैं।

MCP और इस मल्टी-एजेंट दृष्टिकोण के साथ, हम वास्तविक concurrency प्राप्त करते हैं। जब Codex-Risk एजेंट Alpha Vantage API से नेटवर्क अनुरोधों का इंतज़ार कर रहा होता है, तब Codex-UI एजेंट पहले से ही टेबल कॉलम स्कैफ़ोल्ड कर सकता है और CSS क्लासेस सेट कर सकता है।

इन चिंताओं को विभाजित करके, हम 15–20 मिनट के आगे-पीछे चैट की प्रक्रिया को एक सुव्यवस्थित पाइपलाइन में बदल देते हैं। आप कच्चे डेटा फ़ेचिंग से जटिल रिस्क एनालिसिस तक और पूरी तरह इम्प्लिमेंटेड UI फीचर्स तक लगभग 5 मिनट में पहुँच जाते हैं।

सुरक्षा विचार और सीमाएँ

किसी भी ऐसे शक्तिशाली टूल की तरह जो आपके कोड को बाहरी दुनिया से जोड़ता है, हमें सुरक्षा की बात करनी चाहिए। जबकि Codex और MCP अद्भुत क्षमताएँ अनलॉक करते हैं, वे नए अटैक सरफेसेज़ और व्यावहारिक सीमाएँ भी लाते हैं, जिन्हें प्रोडक्शन वातावरण में इन्हें डिप्लॉय करने से पहले समझना जरूरी है।

कॉन्फ़िगरेशन कमजोरियाँ

सबसे महत्वपूर्ण सुरक्षा पहलू स्वयं कॉन्फ़िगरेशन फ़ाइल से जुड़ा है। Codex CLI के पुराने वर्ज़न्स में एक ज्ञात भेद्यता थी जहाँ config.toml और .env फ़ाइल (जो CODEX_HOME को लोकल डायरेक्टरी पर रीडायरेक्ट करती थी) के संयोजन से दुर्भावनापूर्ण कमांड इंजेक्ट किए जा सकते थे। इसे पैच किया जा चुका है, इसलिए यह सख्ती से महत्वपूर्ण है कि आप v0.23.0 या उससे ऊपर का वर्ज़न चला रहे हों।

हालाँकि, सिर्फ़ सॉफ़्टवेयर अपडेट से जोखिम पूरी तरह समाप्त नहीं होता। चूँकि Codex प्रोजेक्ट-स्कोप्ड कॉन्फ़िगरेशन का सम्मान करता है, यदि आप कोई ऐसा रिपो क्लोन करते हैं जिसमें दुर्भावनापूर्ण .codex/config.toml और साथ में .env फ़ाइल हो जो CODEX_HOME=./.codex सेट करती हो, तो उस फ़ोल्डर के अंदर codex चलाना उस फ़ाइल में परिभाषित अप्रत्याशित कमांड्स चला सकता है। 

किसी भी नए प्रोजेक्ट को क्लोन करने पर उसकी कॉन्फ़िगरेशन फ़ाइल का ऑडिट करने की आदत डालें। कुछ भी चलाने से पहले इसे अत्यधिक सावधानी से लें।

MCP की सीमाएँ

व्यावहारिक रूप से, कुछ खुरदरे किनारों की अपेक्षा करें। वर्तमान में, CLI लॉन्च करने पर कोई बिल्ट-इन “कनेक्टिविटी टेस्ट” नहीं है। स्टार्टअप पर यदि कोई MCP सर्वर डाउन या अप्राप्य है तो Codex आपको अपने-आप नहीं बताएगा। आपको मूलतः मॉडल को “मेरे टूल्स जाँचें” जैसा कुछ प्रॉम्प्ट करना पड़ता है ताकि वह कनेक्शन के वास्तव में काम करने की पुष्टि कर सके।

इसके अलावा, उपलब्ध हर टूल इंस्टॉल करना मोहक है, पर आपको चयनात्मक होना चाहिए। यदि आप बहुत अधिक MCP सर्वर जोड़ते हैं, तो मॉडल का प्रदर्शन काफी गिरने लगता है। जितने अधिक टूल्स आप जोड़ेंगे, मॉडल को उतना अधिक “नॉइज़” फ़िल्टर करना होगा, जो उसे भ्रमित कर सकता है या हैलूसिनेशन की ओर ले जा सकता है। बेहतर अभ्यास है कि सिर्फ़ वही MCP सर्वर अटैच करें जिनकी आपको आवश्यकता है।

Codex CLI बनाम Claude Code

अंत में, Codex CLI की उसके नज़दीकी प्रतिस्पर्धी Claude Code से तुलना करना उचित है।

यदि आपका लक्ष्य ऑटोमेशन और कंटीन्युअस इंटीग्रेशन (CI) पाइपलाइंस है, तो Codex CLI आम तौर पर बेहतर विकल्प है। यह हल्का, उपयोगकर्ता-अनुकूल और अत्यधिक स्क्रिप्टेबल है। दूसरी ओर, Claude Code एडिटर के अंदर इंटरैक्टिव कोडिंग वातावरण के रूप में चमकता है, जिसमें रिफैक्टर्स, टेस्ट रन और प्रति-प्रोजेक्ट असिस्टेंट्स के लिए मजबूत बिल्ट-इन UX है।

कॉन्फ़िगरेशन शैलियाँ भी भिन्न हैं। Codex कॉन्फ़िगरेशन के लिए TOML फ़ाइलों पर निर्भर करता है—एक साझा ~/.codex/config.toml जिसे CLI और IDE एक्सटेंशन दोनों उपयोग करते हैं—साथ ही प्रत्येक रिपो के अंदर वैकल्पिक प्रोजेक्ट-लेवल ओवरराइड्स .codex/config.toml के माध्यम से। इसका अर्थ है कि आपका वातावरण डिफ़ॉल्ट रूप से साझा होता है, पर प्रोजेक्ट-प्रति कस्टमाइज़ किया जा सकता है।

Claude Code आमतौर पर JSON-आधारित सेटिंग्स का उपयोग करता है—एक ग्लोबल कॉन्फ़िग (उदाहरण के लिए, ~/.claude.json) और अतिरिक्त प्रोजेक्ट-स्कोप्ड फ़ाइलें (जैसे .mcp.json या प्रोजेक्ट सेटिंग्स) जो प्रत्येक रिपोज़िटरी को अपने MCP सर्वर और व्यवहार परिभाषित करने देती हैं—यह आइसोलेशन सुधारता है, पर प्रति-प्रोजेक्ट सेटअप थोड़ा बढ़ सकता है।

जहाँ दोनों टूल्स AI कोडिंग एजेंट्स का अत्याधुनिक प्रतिनिधित्व करते हैं, उनके बीच चुनाव आपके वर्कफ़्लो पर निर्भर करता है; यदि आप एजेंट को मुख्यतः टर्मिनल या CI जॉब में रहने वाली चीज़ के रूप में सोचते हैं, तो Codex बेहतर बैठता है, जबकि यदि आप मुख्य रूप से एक एडिटर-फ़र्स्ट कोडिंग साथी चाहते हैं, तो Claude Code अक्सर अधिक स्वाभाविक लगता है।

इस तुलना पर गहराई से नज़र डालने के लिए, मैं हमारा Codex बनाम Claude Code गाइड पढ़ने की सलाह देता हूँ।

निष्कर्ष

आज हमने बहुत कुछ कवर किया—MCP की बुनियादी परिभाषाओं से लेकर अपना Codex एजेंट बनाने तक। पर यदि आप इस ट्यूटोरियल से एक ही बात साथ ले जाएँ, तो वह वर्कफ़्लो की शक्ति हो। संपूर्ण प्रक्रिया—अपने MCP सर्वर को कॉन्फ़िगर करना, Codex चलाना, और यह देखना कि टूल्स अपनी ज़रूरत का डेटा खुद खोज लेते हैं—आपको फीचर्स इंसानों से तेज़ बनाने में सक्षम बनाती है।

यदि आप अभी शुरुआत कर रहे हैं, तो मैं सख्ती से सलाह देता हूँ कि शुरुआत में चीज़ों को ज़्यादा जटिल न बनाएं। डॉक्यूमेंटेशन के लिए Context7 से शुरू करें और शायद एक ही API-आधारित MCP—जैसे आज हमने Alpha Vantage सेटअप बनाया। एकाधिक एजेंट्स के साथ काम करने की कोशिश करने से पहले इस फ़्लो में सहज हो जाएँ।

एक बार जब वह आत्मविश्वास आ जाए, तो संभावनाएँ अनंत हैं। अन्य MCPs का अन्वेषण करें। Figma को जोड़ें ताकि डिज़ाइनों से सीधे UI कोड जनरेट हो, या Sentry से कनेक्ट करें ताकि Codex स्वचालित रूप से प्रोडक्शन बग्स का निदान और सुधार कर सके। Codex सबएजेंट्स के साथ प्रयोग करें और देखें कि आप अपनी कितनी रूटीन वर्क डेलीगेट कर सकते हैं। टूल्स यहाँ हैं, शक्तिशाली हैं, और आपके उपयोग के लिए तैयार हैं।

यदि आप AI एप्लिकेशन विकसित करने में रुचि रखते हैं, तो मैं हमारे AI Engineering with LangChain स्किल ट्रैक में नामांकन की सिफारिश करता हूँ। शिक्षण सामग्री AI-नेटिव है, यानी आपको आपका पर्सनल ट्यूटर मिलता है जो आपको आपकी वर्तमान स्तर से शुरू करके AI वर्कफ़्लोज़ इंजीनियरिंग में प्रो बनने के लिए आवश्यक कौशल सिखाता है।