GPT-4.1 गाइड व डेमो प्रोजेक्ट: कीवर्ड कोड सर्च एप्लिकेशन

हाल ही में, OpenAI ने GPT-4.1 फैमिली पेश की, जिसमें तीन वेरिएंट शामिल हैं: GPT-4.1, GPT-4.1 Mini, और GPT-4.1 Nano। ये मॉडल्स कोडिंग और निर्देशों का पालन करने वाले कार्यों में उत्कृष्टता के लिए डिज़ाइन किए गए हैं, और अपने पूर्ववर्तियों की तुलना में महत्वपूर्ण प्रगति प्रदान करते हैं। 

इनकी प्रमुख विशेषताओं में से एक है विस्तारित कॉन्टेक्स्ट विंडो, जो 1 मिलियन टोकन तक का समर्थन करती है—जो GPT-4 की क्षमता से आठ गुना से अधिक है। यह सुधार मॉडलों को व्यापक इनपुट, जैसे संपूर्ण कोड रिपोजिटरी या मल्टी-डॉक्यूमेंट वर्कफ्लो, संभालने में सक्षम बनाता है। 

इस ट्यूटोरियल में, हम एक ऐसा प्रोजेक्ट बनाकर GPT-4.1 की क्षमताओं का पता लगाएंगे जो उपयोगकर्ताओं को उनके प्रॉम्प्ट के कीवर्ड का उपयोग करके पूरी कोड रिपोजिटरी में खोज करने में सक्षम बनाता है। इसके बाद, रिपोजिटरी से संबंधित सामग्री को उपयोगकर्ता के प्रॉम्प्ट के साथ GPT-4.1 मॉडल को प्रदान किया जाएगा। 

परिणामस्वरूप, हम एक इंटरैक्टिव एप्लिकेशन बनाएंगे जो उपयोगकर्ताओं को अपनी कोड रिपोजिटरी के साथ चैट करने और GPT-4.1 का उपयोग करके पूरे सोर्स कोड का विश्लेषण व सुधार करने की सुविधा देता है।

हम अपने पाठकों को एआई की ताज़ा प्रगति से अपडेट रखते हैं The Median के जरिए—हमारा मुफ़्त शुक्रवार न्यूज़लेटर जो हफ्ते की बड़ी खबरों को सरल भाषा में बताता है। सब्सक्राइब करें और हर हफ्ते कुछ ही मिनटों में अपडेट रहें:

GPT-4.1 मॉडलों के साथ शुरुआत

प्रोजेक्ट बनाने से पहले, GPT-4.1 मॉडलों के विभिन्न संस्करणों का परीक्षण करना और नए responses API का पता लगाना ज़रूरी है। यह उन्नत API पूर्व आउटपुट को इनपुट के रूप में उपयोग करके स्टेटफुल इंटरैक्शन सक्षम करता है, टेक्स्ट और छवियों जैसे मल्टीमॉडल इनपुट का समर्थन करता है, और फाइल सर्च, वेब सर्च, तथा फ़ंक्शन कॉलिंग के माध्यम से बाहरी सिस्टम एकीकरण के लिए इन-बिल्ट टूल्स के साथ मॉडल की क्षमताओं का विस्तार करता है।

शुरू करने के लिए, सुनिश्चित करें कि आपके पास OpenAI Python क्लाइंट का नवीनतम संस्करण इंस्टॉल हो। आप टर्मिनल में निम्न कमांड चलाकर ऐसा कर सकते हैं:

$ pip install -U openai -qसंचालित द्वारा

1. टेक्स्ट जनरेशन के लिए GPT-4.1 Nano मॉडल का उपयोग

इस उदाहरण में, हम GPT-4.1 Nano मॉडल का उपयोग करेंगे, जो गति और किफ़ायतीपन के लिए अनुकूलित है, टेक्स्ट जनरेट करने के लिए। 

सबसे पहले, हम OpenAI क्लाइंट को इनिशियलाइज़ करेंगे और रिस्पॉन्स API का उपयोग करके एक प्रतिक्रिया जनरेट करेंगे।

from openai import OpenAI
from IPython.display import Markdown, display

client = OpenAI()

response = client.responses.create(
    model="gpt-4.1-nano",
    input= "Write a proper blog on getting rich."
)

Markdown(response.output_text)संचालित द्वारा

GPT-4.1 Nano मॉडल ने सुव्यवस्थित और संक्षिप्त प्रतिक्रिया प्रदान की।

2. इमेज अंडरस्टैंडिंग के लिए GPT-4.1 Mini मॉडल का उपयोग

अब हम GPT-4.1 Mini मॉडल का परीक्षण करेंगे—उसे एक इमेज URL देंगे और उससे दार्शनिक शैली में छवि का वर्णन करने के लिए कहेंगे।

response = client.responses.create(
    model="gpt-4.1-mini",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": "Please describe the image as a philosopher would."},
            {
                "type": "input_image",
                "image_url": "https://thumbs.dreamstime.com/b/lucha-de-dos-vacas-56529466.jpg",
            },
        ],
    }],
)

print(response.output_text)संचालित द्वारा

GPT-4.1 Mini मॉडल ने छवि का विस्तृत और रचनात्मक वर्णन दिया, जिससे उसकी दृश्य सामग्री समझने की क्षमता प्रदर्शित हुई।

3. कोड जनरेशन के लिए GPT-4.1 (फुल) मॉडल का उपयोग

अब, हम “फुल” GPT-4.1 मॉडल का उपयोग करके कोड जनरेट करेंगे। 

इस उदाहरण में, हम मॉडल को सिस्टम इंस्ट्रक्शंस और एक यूज़र प्रॉम्प्ट देंगे और स्ट्रीम रिस्पॉन्स सक्षम करेंगे।

import sys

# Request a streamed response from the model.
stream = client.responses.create(
    model="gpt-4.1",
    instructions="You are a machine learning engineer, which is an expert in creating model inference.",
    input="Create a FastAPI app for image classification",
    stream=True,
)

# Iterate over stream events and print text as soon as it's received.
for event in stream:
    # Check if the event includes a text delta.
    if hasattr(event, "delta") and event.delta:
        sys.stdout.write(event.delta)
        sys.stdout.flush()संचालित द्वारा

हमने रीयल-टाइम में स्ट्रीमिंग रिस्पॉन्स दिखाने के लिए सिस्टम-लेवल आउटपुट (sys.stdout) का उपयोग किया।

4. फाइल इनपुट के साथ GPT-4.1 मॉडल द्वारा कोड जनरेशन

अंत में, हम GPT-4.1 मॉडल की बड़ी कॉन्टेक्स्ट विंडो का परीक्षण करेंगे—उसे इनपुट के रूप में एक Python फाइल देंगे। फाइल Base64 फॉर्मेट में एन्कोड की जाती है और उपयोगकर्ता निर्देशों के साथ मॉडल को भेजी जाती है।

import base64
from openai import OpenAI
client = OpenAI()

with open("main.py", "rb") as f:
    data = f.read()

base64_string = base64.b64encode(data).decode("utf-8")

response = client.responses.create(
    model="gpt-4.1",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_file",
                    "filename": "main.py",
                    "file_data": f"data:text/x-python;base64,{base64_string}",
                },
                {
                    "type": "input_text",
                    "text": "Enhance the code by incorporating additional features to improve the user experience.",
                },
            ],
        },
    ]
)

Markdown(response.output_text)संचालित द्वारा

GPT-4.1 मॉडल ने कोड में सुधार के लिए संदर्भ-सचेत सुझाव दिए, जिससे यह साबित हुआ कि वह बड़े इनपुट संभाल सकता है।

यदि आपको ऊपर दिया कोड चलाने में कोई समस्या आती है, तो कृपया DataLab वर्कबुक देखें: Playing with GPT-4.1 API — DataLab.

कीवर्ड कोड सर्च एप्लिकेशन बनाना 

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

एप्लिकेशन तीन प्रमुख भागों में बंटा है:

1. कोडबेस खोजें

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

searcher.py:

import os

def search_codebase(directory: str, keywords: list, allowed_extensions: list) -> list:
    """
    Search for code snippets in the codebase that match any of the given keywords.
    Returns a list of dictionaries with file path, the line number where a match was found,
    and a code snippet that includes 2 lines of context before and after the matched line.
    """
    matches = []

    for root, _, files in os.walk(directory):
        for file in files:
            if file.endswith(tuple(allowed_extensions)):
                file_path = os.path.join(root, file)
                try:
                    with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
                        lines = f.readlines()
                    for i, line in enumerate(lines):
                        # Check if any keyword is in the current line (case insensitive)
                        if any(keyword in line.lower() for keyword in keywords):
                            snippet = {
                                "file": file_path,
                                "line_number": i + 1,
                                "code": "".join(lines[max(0, i - 2) : i + 3]),
                            }
                            matches.append(snippet)
                except Exception as e:
                    print(f"Skipping file {file_path}: {e}")
    return matchesसंचालित द्वारा

2. GPT 4.1 क्वेरी

जब प्रासंगिक कोड स्निपेट्स पहचान लिए जाते हैं, अगला चरण GPT-4.1 को क्वेरी करना है ताकि कोड के बारे में स्पष्टीकरण या इनसाइट्स जनरेट किए जा सकें। query_gpt फ़ंक्शन डेवलपर का प्रश्न और मिले हुए स्निपेट्स को इनपुट के रूप में लेता है और विस्तृत प्रतिक्रिया लौटाता है।

gpt_explainer.py:

import os

from openai import OpenAI


def query_gpt(question: str, matches: list):
    """
    Queries GPT-4.1 with the developer's question and the relevant code snippets,
    then returns the generated explanation.
    """
    if not matches:
        return "No code snippets found to generate an explanation."

    # Combine all matches into a formatted string
    code_context = "\n\n".join(
        [
            f"File: {match['file']} (Line {match['line_number']}):\n{match['code']}"
            for match in matches
        ]
    )

    # Create the GPT-4.1 prompt
    system_message = "You are a helpful coding assistant that explains code based on provided snippets."
    user_message = f"""A developer asked the following question:
                    "{question}"
                    Here are the relevant code snippets:
                    {code_context}
                    Based on the code snippets, answer the question clearly and concisely.
                    """

    # Load API key from environment variable
    api_key = os.environ.get("OPENAI_API_KEY")
    if not api_key:
        return "Error: OPENAI_API_KEY environment variable is not set."

    # Create an OpenAI client using the API key
    client = OpenAI(api_key=api_key)

    try:
        # Return the stream object for the caller to process
        return client.responses.create(
            model="gpt-4.1",
            input=[
                {"role": "system", "content": system_message},
                {"role": "user", "content": user_message},
            ],
            stream=True,
        )

    except Exception as e:
        return f"Error generating explanation: {e}"संचालित द्वारा

3. कीवर्ड कोड सर्च चैट एप्लिकेशन

एप्लिकेशन का अंतिम भाग इंटरैक्टिव चैटबॉट है, जो सब कुछ एक साथ जोड़ता है। यह डेवलपर्स को अपने कोडबेस के बारे में प्रश्न पूछने, क्वेरी से कीवर्ड निकालने, प्रासंगिक स्निपेट्स के लिए कोडबेस में खोज करने, और उपयोगकर्ता के प्रश्न के साथ सब कुछ GPT-4.1 को भेजकर प्रतिक्रिया जनरेट करने देता है।

main.py:

import argparse

from gpt_explainer import query_gpt
from searcher import search_codebase


def print_streaming_response(stream):
    """Print the streaming response from GPT-4.1"""
    print("\nGPT-4.1 Response:")
    for event in stream:
        # Check if the event includes a text delta.
        if hasattr(event, "delta") and event.delta:
            print(event.delta, end="")
    print("\n")


def main():
    parser = argparse.ArgumentParser(
        description="Keyword-Based Code Search with GPT-4.1"
    )
    parser.add_argument("--path", required=True, help="Path to the codebase")
    args = parser.parse_args()

    allowed_extensions = [".py", ".js", ".txt", ".md", ".html", ".css", ".sh"]

    print("Welcome to the Code Search Chatbot!")
    print("Ask questions about your codebase or type 'quit' to exit.")

    while True:
        question = input("\nEnter your question about the codebase: ")

        if question.lower() == "quit":
            print("Exiting chatbot. Goodbye!")
            break

        # Extract keywords from the question and remove stop words
        stop_words = {'a', 'an', 'the', 'and', 'or', 'but', 'is', 'are', 'was', 'were',
                     'in', 'on', 'at', 'to', 'for', 'with', 'by', 'about', 'like',
                     'from', 'of', 'as', 'how', 'what', 'when', 'where', 'why', 'who'}
        keywords = [word for word in question.lower().split() if word not in stop_words][:5]

        print("Searching codebase...")
        matches = search_codebase(args.path, keywords, allowed_extensions)

        if not matches:
            print("No relevant code snippets found.")
            continue

        print("Querying GPT-4.1...")
        stream = query_gpt(question, matches)
        print_streaming_response(stream)


if __name__ == "__main__":
    main()संचालित द्वारा

यह चैटबॉट डेवलपर्स के लिए सुगम अनुभव प्रदान करता है, जिससे वे अपने कोडबेस के साथ इंटरैक्ट कर सकें और एआई-संचालित इनसाइट्स प्राप्त कर सकें। 

प्रोजेक्ट में एक कोड रिपोजिटरी (kingabzpro/Keyword-Code-Search) भी शामिल है, जिसमें सोर्स कोड और उसे उपयोग करने के निर्देश मौजूद हैं। 

कीवर्ड कोड सर्च एप्लिकेशन का परीक्षण

इस सेक्शन में, हम टर्मिनल में एप्लिकेशन चलाकर और इसकी विशेषताएँ देखकर कीवर्ड कोड सर्च एप्लिकेशन का परीक्षण करेंगे। 

एप्लिकेशन चलाने के लिए, आपको उस कोड रिपोजिटरी का पाथ देना होगा जिसे आप एनालाइज़ करना चाहते हैं। इस उदाहरण में, हम “Redis ML प्रोजेक्ट” का उपयोग करेंगे।

$ python main.py --path C:\Repository\GitHub\Redis-ml-project  संचालित द्वारा

आपका स्वागत संदेश और निर्देश दिखेंगे। बस अपने कोड के बारे में प्रश्न लिखें या कोडबेस के किसी हिस्से को बेहतर करने के लिए कहें।

Welcome to the Code Search Chatbot!
Ask questions about your codebase or type 'quit' to exit.

Enter your question about the codebase: help me improve the training scriptसंचालित द्वारा

एप्लिकेशन कोडबेस में प्रासंगिक स्निपेट्स खोजेगा और GPT-4.1 से प्रतिक्रिया जनरेट करने के लिए क्वेरी करेगा। 

Searching codebase...
Querying GPT-4.1...

GPT-4.1 Response:
Certainly! Based on the provided snippets, here's how you can **improve the training script (`train.py`)** for your phishing email classification proje...........संचालित द्वारा

आप पूरे प्रोजेक्ट को समझने के लिए फॉलो-अप प्रश्न पूछ सकते हैं।

Enter your question about the codebase: help me understand the projectसंचालित द्वारा

यह विस्तृत व्याख्या डेवलपर्स को प्रोजेक्ट के उद्देश्य, कार्यक्षमता और संरचना समझने में मदद करती है।

Searching codebase...
Querying GPT-4.1...

GPT-4.1 Response:
Certainly! Here's a concise overview of the project based on your code snippets:

## Project Purpose

**Phishing Email Classification App with Redis**  
This project classifies emails as "Phishing" or "Safe" using machine learning and serves predictions via a web API. It also uses Redis for caching predictions to optimize performance…………संचालित द्वारा

एप्लिकेशन से बाहर निकलने के लिए, बस ‘quit’ टाइप करें:

Enter your question about the codebase: quitसंचालित द्वारा

Exiting chatbot. Goodbye!संचालित द्वारा

कीवर्ड कोड सर्च एप्लिकेशन छोटा लेकिन शक्तिशाली टूल है, जो डेवलपर्स को अपनी कोड रिपोजिटरी के साथ चैट करने देता है। यह कीवर्ड-आधारित कुशल कोड सर्चिंग को GPT-4.1 की संदर्भ-सचेत प्रतिक्रियाएँ जनरेट करने की क्षमता के साथ जोड़ता है। चाहे आपको अपने कोडबेस के किसी हिस्से में सुधार करना हो या पूरे प्रोजेक्ट को समझना हो, यह एप्लिकेशन सहज और स्वाभाविक अनुभव प्रदान करता है।

अंतिम विचार

पूरे एआई परिदृश्य में अब हाइप और सतही बेंचमार्क से हटकर वास्तविक मूल्य प्रदान करने पर ध्यान दिया जा रहा है, महज़ भ्रम पैदा करने पर नहीं। GPT-4.1 मॉडल डेवलपर्स के अनुभव को बेहतर बना रहे हैं—बड़े भाषा मॉडल्स को बॉक्स से बाहर ही अत्यंत सटीक और रन करने योग्य कोड जनरेट करने में सक्षम बनाते हुए। साथ ही, ये मॉडल बड़े कॉन्टेक्स्ट विंडो के साथ आते हैं, जिससे वे एक ही बार में पूरी कोड रिपोजिटरी समझ सकते हैं। 

यदि आप OpenAI API के साथ हैंड्स-ऑन होना चाहते हैं, तो हमारा कोर्स देखें Working with the OpenAI API और एआई-संचालित एप्लिकेशंस बनाना शुरू करें। आप हमारे Responses API पर ट्यूटोरियल भी देख सकते हैं और नए o4-mini रीजनिंग मॉडल के बारे में अधिक जानें।