# क्यों मैं लैंगाइन का उपयोग नहीं करते (और मैं इसके बजाय क्या करते हैं)

<!--category-- AI, Architecture, LLM, Agents, Systems Design, C# -->
<datetime class="hidden">2025-12-18T10:00</datetime>

"यह मानक है," उन्होंने कहा. "सभी उदाहरण यह इस्तेमाल करते हैं." और वे सही थे अगर आप पायथन पर्यावरण में हैं, SELLONONONS हर जगह है. "

लेकिन यहाँ बात है: मैं LCachain से दूर नहीं है क्योंकि यह बुरा है. मैं इससे दूर हूँ क्योंकि यह मैं पहले से ही स्पष्ट रूप से हल समस्याओं को हल कर देता हूँ, और मेरे मामलों के लिए - C# C#, स्थानीय गोपनीयता, गोपनीयता, PRACARTACACACANACANANACACANANANANANANANACANANANANANANAN के बजाय विरोध को जोड़ता है.

यह एक विरोधी सींगिन पोस्ट नहीं है। यह समझ के बारे में एक पोस्ट है क्या समस्याओं के समाधान के बारे में है, और आपको एहसास है कि आप उन्हें जरूरत नहीं हो सकता।

**Sisisis: अगर आप समझते हैं कि समस्या SCakyys हल, आप Layhain की जरूरत नहीं है.**

[TOC]

## वास्तव में कौन - सा लावेन वास्तव में अच्छा करता है

चलो सबसे पहले उचित हो. LCachain कई बातों में सीमा:

**विश्‍व - दर्शन** - आप मिनट में काम कर सकते हैं. शुरू होने वाले उदाहरण वास्तव में अच्छा हैं.

**पायथन पर्यावरण एकीकरण** - अगर आप पहले से ही पायथन/Jues/plays दुनिया में कर रहे हैं, LCaks सभी एक साथ समुद्रीय।

**दीवार गिराना** - लोगों के लिए नए LLLM के लिए, यह उपयोगी एक संकेतक प्रदान करता है: प्रायोगिक प्रारूप, उपकरण कॉल पैटर्न, स्मृति प्रबंधन, सदिशी संयोजन.

LCakiin एक है **एकीकरणीकरणीकरण**"मेरे पास एक विचार है" के लिए "मैं एक डेमो है" के लिए। यह मूल्यवान है।

लेकिन यह भी है जहाँ समस्या सी# डेवलपर निर्माण तंत्र के रूप में मेरे लिए शुरू होती है।

## समस्याओं का हल

एक फ्रेमवर्क को नज़रअंदाज़ करने से पहले, आप यह क्या समस्या हल कर रही है समझ की जरूरत है.

1. **कॉन्टेक्स्ट निर्माण** - निर्माण स्कीमा, नमूने, इतिहास, और प्रतिबन्धों से प्रेरित
2. **औज़ार- पट्टी** - व्यक्तिगत तर्क के साथ बहुत से औज़ार कॉल को अनदेखा कर रहा है
3. **स्थिति प्रबंधन** - कई बार वार्तालाप के संदर्भ को बनाए रखना
4. **फिर कोशिश करें तथा त्रुटि नियंत्रण** - सहायक प्राप्त कर रहे हैं जब LL अमान्य आउटपुट उत्पन्न करता है
5. **बहु- चरण तर्क** - जटिल कार्यों को अनुक्रम में तोड़ रहे हैं ("वेड शैली)
6. **ऑब्सर्वेटरी** - आप सच में क्या हुआ देख रहे हैं पर मृत्यु के दौरान क्या हुआ

सवाल यह है: क्या इन्हें हल करने के लिए आपको एक फ्रेमवर्क की ज़रूरत है?

## जहाँ Lacakiin दर्द करने के लिए शुरू होता है

मेरे काम - निर्माण उत्पादन के लिए स्थानीय LLLM, सख़्त गोपनीयता माँगों के साथ प्रणाली, और विचारात्मक व्यवहार - कुशल ढंग से कई क्षेत्रों में संघर्षों का परिचय देता है ।

### छुपा स्थिति तथा आईप्लिकल नियंत्रण प्रवाह

LLLCONSin आप के लिए स्मृति और संदर्भ का प्रबंधन करता है. यह ध्वनि जब तक आप डीबग करने की जरूरत है कि क्यों अपने इवेचित से अधिक आयु 10,000 संकेत, या क्यों अचानक आप से बातचीत इतिहास में पहुँच गया है आप सोचा था कि आप को मंजूरी दी थी.

फ्रेमवर्क जांच, स्मृति को संभालता है, और कार्यान्वित करने के आदेश को पूर्ण रूप से संभालता है. जब कुछ गड़बड़ होती है, आप फ्रेमवर्क के व्यवहार को डिबगिंग कर रहे हैं, अपने कोड के व्यवहार को नहीं.

### फ्रेमवर्क- कोल्ड सोच

एक बार आप Lakyhain ले, आप डिजाइन शुरू **लैंगाइन के लिए**. आपकी बनावट फ्रेमवर्क की एक वेश्याओं के साथ जोड़ा जाता है: जंजीर, एजेंट, Rarters, स्मृति बफर.

यह Lacayin - सभी फ्रेमवर्क यह करने के लिए अनोखा नहीं है. लेकिन एक तेजी से तेजी से जाँच क्षेत्र में, जहां सही एक lems अभी तक तय नहीं कर रहे हैं, एक फ्रेमवर्क की दुनिया दृश्य करने के लिए शामिल है.

### पायथन ईम्प्ड मिसमैच

LCacanin मान्स:

- लंबी उम्र की प्रक्रिया (नोटबुक- शैली का कार्य प्रवाह)
- कुकीज़ योग्य वैश्विक स्थिति
- पायथन के गतिशील टाइपिंग तथा बत्तख टाइप
- आई/ ओ पैटर्न बन्द किया जा रहा है

एक के रूप में.NT डेवलपर, मुझे लगता है:

- निवेदनित जीवन (SaseP. e. lacut पैटर्न)
- अवैध या प्रत्यक्ष रूप से 'metad स्थिति
- मजबूत टाइपिंग तथा कंपाइलिंग समय सुरक्षा
- एएसी/ बेलग्रेड हर जगह इंतजार करें

वह [लैंगाइन .नेट पोर्ट](https://github.com/tryAGI/LangChain) मौजूद है, लेकिन वे पायथन संस्करण के साथ शिकार कर रहे हैं, और एक सारस अभी भी C# के लिए विदेशी लग रहा है.

### उत्पादन वास्तविकताएँ बढ़ रही हैं

जब आप निर्माता से उत्पादन करने के लिए कदम, आप की जरूरत है:

- **एटर्मल्शन** - वही इनपुट उत्पन्न करने योग्य व्यवहार पैदा करना चाहिए
- **वैधता** - सुनिश्चित करें किLM आउटपुट सुरक्षित है इसे चलाने से पहले
- **सेंडबाक्स** - सीमित करें क्या उत्पन्न कोड वास्तव में कर सकता है
- **लागत नियंत्रण** - ट्रैक टोकन उपयोग तथा सीमाएँ
- **स्थानीय इनफिनिट** - बादल डिपेंडेंसीज़ के बिना मॉडल ऑफ़लाइन चलाएँ

यह डेमोओं के लिए ठीक है, यह उत्पादन के लिए एक समस्या है.

## इसके बजाय क्या मैं निर्माण करता हूँ

यहाँ मैं इस्तेमाल मानसिक मॉडल है: **TLMMM इंजन हैं, नहीं DELM इंजन.**

### LLM कार्य:

- **व्याख्या** - उपयोक्ता को प्राकृतिक भाषा से समझने में त्रुटि
- **योजना** - जटिल कार्यों को चरण में तोड़ रहे हैं
- **अनुवाद** - स्ट्रक्चर फॉर्मेट में निर्यात किया जा रहा है ( एसक्यूएल, JSON, फंक्शन कॉल)

### LLM सिर्फ नहीं:

- **कम्प्लीशन्स गणना करें** - 1,00,000 पंक्तियाँ
- **डाटासेट्स स्कैन करें** - बड़ी फ़ाइलों के माध्यम से खोज रहा है
- **अपनी स्थिति** - लंबी-योग्य स्मृति बनाए रखना

सिद्धांत: **इंजन की गणना.**

यह अलग ड्राइव मैं निर्माण सब कुछ.

### एक्सपोजर संदर्भ नहीं, बल्कि मैजिक मेमोरी

फ्रेमवर्क-मेन्ड मेमोरी के बजाय, मैं संदर्भों को प्रत्यक्ष रूप से प्रति निवेदन बनाता हूं:

```csharp
public class QueryContext
{
    public List<ColumnInfo> Schema { get; set; }
    public List<Dictionary<string, string>> SampleRows { get; set; }
    public List<ConversationTurn> History { get; set; }
    public string UserQuestion { get; set; }
}
```

हर आसान निर्माण दृश्‍य है. मैं वास्तव में क्या LLLM के लिए भेजा जा रहा है पता है क्योंकि मैं अपने आप को बनाया है:

```csharp
private string BuildPrompt(QueryContext context)
{
    var sb = new StringBuilder();
    sb.AppendLine("You are a SQL expert. Generate a query based on:");
    sb.AppendLine();
    
    // Schema
    sb.AppendLine("Schema:");
    foreach (var col in context.Schema)
        sb.AppendLine($"  - {col.Name}: {col.Type}");
    
    // History (if any)
    if (context.History.Any())
    {
        sb.AppendLine("\nPrevious conversation:");
        foreach (var turn in context.History.TakeLast(3))
            sb.AppendLine($"  Q: {turn.Question} → SQL: {turn.Sql}");
    }
    
    // Current question
    sb.AppendLine($"\nQuestion: {context.UserQuestion}");
    sb.AppendLine("Generate SQL (no explanation, just the query):");
    
    return sb.ToString();
}
```

कोई गुप्त स्थिति नहीं, कोई जादुई जादू का निर्माण. बस सुस्पष्ट वाक्यांश निर्माण. जब यह गलत है, मुझे पता है क्यों है.

### परत को द्वेंशनिक रूप से चलाया जा रहा है

मैं कुछ भी करने के बजाय, मैं इसे बनाने के लिए इस्तेमाल करता हूँ **फिर प्राप्त करें (_R)**, फिर उस इरादा को चालू करनेवाले इंजन के माध्यम से चलाने के लिए:

- **एसक्यूएल इंजिन** (डिस्क) - डाटा कालों के लिए
- **खोज इंजिन** (Lequin, पोस्ट- पाठ) - प्राप्त करने के लिए दस्तावेज़ वापसी के लिए
- **नियम इंजन** - व्यापार तर्क के लिए
- **डोमेन सेवा** - अतिरिक्त ऑपरेशनों के लिए

TLM एसक्यूएल उत्पन्न करता है. DatDB इसे चलाता है.LM डाटा कभी नहीं दिखता है:

```csharp
// LLM generates intent
var sql = await GenerateSqlAsync(context);

// Validate before execution
var error = ValidateSql(connection, sql);
if (error != null)
{
    // Retry with error feedback
    sql = await GenerateSqlAsync(context, previousError: error);
}

// Execute in sandboxed engine
var results = ExecuteQuery(connection, sql);
```

यह सुरक्षित, तेजी से, और डिबग नहीं चला सकता. `DROP TABLE` क्योंकि मैं सबसे पहले एसक्यूएल को वैध करता हूँ. लेलएम डाटा लीक नहीं कर सकता क्योंकि यह कभी नहीं आंकड़ा - केवल स्कीमा को देखता है.

## acret उदाहरण: CSV जांच बिना फ्रेमवर्क

मैंने हाल ही में लिखा था [स्थानीय CSVM के साथ बड़ी सीएसवी फ़ाइलों का विश्लेषण करें](https://mostlylucid.net/blog/analysing-large-csv-files-with-local-llms). बनावट:

**उपयोक्ता प्रश्न QXML TSBBGEX अंजाम**

LLL प्राप्त करता है:

- सीएसवी प्रसंग ( स्तंभ नाम तथा प्रकार)
- 3 नमूना पंक्तियाँ (संत्र डाटा प्रारूप को समझने के लिए)
- उपयोक्ता का प्रश्न

LLM उत्पन्न करता है:

- डी- एसक्यूएल क्वैरी

तब तंत्र:

- एसक्यूएल का उपयोग करता है `EXPLAIN` (कांची सिंटेक्स त्रुटि बिना )
- सीएसवी फ़ाइल पर क्वैरी निष्पादित करता है
- उपयोक्ता को लौटाया परिणाम बताता है

LLM कभी वास्तविक डाटा नहीं देखता. यह सिर्फ संरचना को देखता है.

यह है कि LCacagin एक "पीड़ा" - एक प्रणाली जो एक काम बनाने के लिए प्रयोग करता है, उन्हें रद्द करता है, और संभवतः असफल पर फिर से कोशिश करता है.

सिवाय मैंने इसे ~200 पंक्ति में बनाया C# कोई फ्रेमवर्क के साथ:

```csharp
public class CsvQueryService
{
    private readonly OllamaApiClient _ollama;
    private readonly string _model;
    
    public async Task<QueryResult> QueryAsync(string csvPath, string question)
    {
        using var connection = new DuckDBConnection("DataSource=:memory:");
        connection.Open();
        
        // 1. Build context
        var context = BuildContext(connection, csvPath, question);
        
        // 2. Generate SQL
        var sql = await GenerateSqlAsync(context);
        
        // 3. Validate
        var error = ValidateSql(connection, sql);
        if (error != null)
        {
            // Retry once with error feedback
            sql = await GenerateSqlAsync(context, error);
        }
        
        // 4. Execute
        return ExecuteQuery(connection, sql);
    }
}
```

यही कारण है कि यह है। कोई जंजीर, कोई एजेंट फ्रेमवर्क, कोई जादू। बस स्पष्ट रूप से इ.

## एक एजेंट, वास्तव में, क्या है?

शब्द "स्टी" हमेशा के आसपास फेंक दिया जाता है, आम तौर पर मतलब है "किसी भी वस्तु से जुड़े कुछ भी" का मतलब है। चलो ठीक है।

एक एजेंट है:

- **लूप** - यह बहुत से इटरेशन चलाता है
- **स्थिति के साथ** - यह याद है कि क्या कोशिश की है
- **उपकरण के साथ** - यह दुनिया में क्रियाएँ ले जा सकते हैं
- **फ़ीडबैक के साथ** - यह परिणाम देखता है और समायोजन करता है

एक एजेंट है **नहीं a**यह एक पैटर्न है.

C# में मेरे एजेंट पैटर्न:

```csharp
public class Agent
{
    private readonly List<ConversationTurn> _history = new();
    
    public async Task<string> RunAsync(string goal)
    {
        while (!IsGoalAchieved(goal))
        {
            // 1. Generate next action based on history
            var action = await GenerateActionAsync(goal, _history);
            
            // 2. Validate before executing
            if (!IsActionSafe(action))
            {
                _history.Add(new ConversationTurn 
                { 
                    Action = action, 
                    Result = "REJECTED: Unsafe action" 
                });
                continue;
            }
            
            // 3. Execute through deterministic tool
            var result = await ExecuteActionAsync(action);
            
            // 4. Record and continue
            _history.Add(new ConversationTurn { Action = action, Result = result });
        }
        
        return GenerateSummary(_history);
    }
}
```

यह एक एजेंट है. यह राज्य, उपकरण, और फ़ीडबैक के साथ एक लूप है. मैं इसे 30 लाइन में लिखा. मुझे एक फ्रेमवर्क की जरूरत नहीं थी.

## जहाँ जेनेरिक एजेंट फ्रेमवर्क फिट करता है

.EEECT पर्यावरण के लिए उचित होने के लिए, माइक्रोसॉफ़्ट ने छोड़ दिया है [माइक्रोसॉफ्ट एजेंट फ्रेमवर्क](https://learn.microsoft.com/en-us/agent-framework/overview/agent-framework-overview) यही कारण है कि उद्देश्य-टी डेवलपर निर्माण एआई सिस्टमों को बनाने के लिए।

### माइक्रोसॉफ़्ट एजेंट फ्रेमवर्क सही मिलता है

प्लगइन (जो पहले Microsoft. विस्तार के रूप में जाना जाता है) प्रदान करता है:

- **एक छोटा - सा रेडियो देखा** - आप एजेंट लूप नियंत्रित करते हैं, फ्रेमवर्क नहीं
- **टाइपिंग चालू करें (l)** - औजार परिभाषाओं और फंक्शन कॉल के लिए कम्पाइल-समय सुरक्षा
- **प्रथम-क्लासबॉयरनेसGenericName** - बनाया गया-इनपिंग, लॉगिंग, और खोलने के माध्यम से ट्रेसी वितरित
- **छोटे आकार की सीमाएँ** - उत्पादन के लिए बनाया गया है .
- **मल्टी- moml समर्थन** - ओपनAREACA, डेम्पो, ओलमा, और अन्य सेवाएँ
- **एक्लिप्टिक कर्नेलीकरण** - माइक्रोसॉफ़्ट के विस्तृत एआई के ढेर के साथ काम करता है

कुंजी अवयव:

- `IChatClient` - गपशप पूर्णता के लिए एकीकृत इंटरफेस
- `IEmbeddingGenerator` - सदिशों के पार आपूर्तििंग्स
- `AIFunction` - वर्ग सुरक्षित फंक्शन कॉल
- लॉगिंग के लिए मध्य ऐम्पेन - लॉगिंग, का पुनः कोशिश करें, C कैशिंग, TICKS

**उदाहरण:**

```csharp
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddChatClient(builder => 
    builder.UseOllama("llama3.2")
           .UseOpenTelemetry()
           .UseLogging());

var app = builder.Build();

app.MapPost("/chat", async (IChatClient client, string message) =>
{
    var response = await client.CompleteAsync(message);
    return response.Content;
});
```

### जहाँ मैं अब भी नीचे नीचे रहना है

यहां तक कि Microsoft के फ्रेमवर्क के साथ भी, मैं रेडियो कोरंट साफ रखने के लिए पसंद करते हैं:

**मैं नहीं चाहता:**

- **अपारदर्शी प्लानर** - प्लगइन एक निश्चित निर्णय है जो कॉल करने के लिए उपकरण
- **इम्पैक्ट औजार चयन** - प्राकृतिक भाषा के वर्णन पर आधारित जादू routing
- **छुपी तर्क फिर से कोशिश करें** - फ्रेमवर्कीन त्रुटि मैं निरीक्षण नहीं कर सकते

**मैं चाहता हूँ:**

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

Microsoft के एजेंट फ्रेमवर्क के करीब है कि मैं कैसे Lacachain से लगता है. यह उदाहरण है. NenT पैटर्न, इंजेक्शन ठीक से प्रयोग करता है, और पर्यावरण के लिए लड़ाई नहीं करता है. लेकिन मैं अभी भी अपने आप को लिखने के लिए पसंद करता है.

**माइक्रोसॉफ़्ट एजेंट फ्रेमवर्क का उपयोग करने के लिए:**

- फंक्शन कॉल के साथ गपशप अनुप्रयोग बनाया जा रहा है
- बहु- मोड समर्थन की आवश्यकता है ( ओपन- डिज़ाइन, एमिला, ओएलमा के बीच)
- विडगेट सुविधाओं (टेलीज़, लॉगिंग, वितरित प्राप्ति)
- एक टीम में काम करना जो फ्रेमवर्क संगतता को पसन्द करता है
- सेप्टिक कर्नेल के शीर्ष पर निर्माण

**जब मिटाया जाता है:**

- आप एजेंट लूप पर पूरा नियंत्रण की जरूरत है
- आप मनपसंद तर्क पैटर्न निर्माण कर रहे हैं
- आप शून्य एक टेराइड चाहते हैं
- आप विशिष्ट उपयोग मामलों के लिए अनुकूलनशील हैं (जैसे CSV या वेब जाँचिंग)
- आप वास्तव में यह कैसे काम करता है समझना चाहते हैं

फ्रेमवर्क कवरिंग निर्णयों को समाप्त नहीं करता है. आप अभी भी संदर्भ में क्या डालने के लिए चुनते हैं, डेटा को पुनः करने के लिए, और जब कोशिश करने के लिए. यह सिर्फ नलिंग आसान बनाता है.

## क्यों यह स्केल अच्छा लंबा पद

बहुत से कारणों के लिए फ्रेमवर्क-रहित तंत्र बेहतर:

**परफार्मेंस** - कोई छोटा कपड़ा नहीं. मेरी सीएसवी क्वैरी सेवा सब-100m चलाता है क्योंकि वहाँ ब्लूएम और DDB के बीच कोई फ्रेमवर्क नहीं है.

**लागत अनुमानीय** - मैं वास्तव में क्या LLLM करने के लिए चला जाता है नियंत्रण. कोई गुप्त रिप्रेचिक स्मृति से.

**डिबगGenericName** - जब कुछ ब्रेक हो, मैं अपने कोड को डिबगिंग कर रहा हूँ, नहीं एक फ्रेमवर्क के जादू को उलटा करने के लिए.

**गोपनीयता** - सख्त डेटा उच्च आवश्यकताओं के साथ व्यवस्थाओं के लिए, पता है कि क्या मशीन मामलों को छोड़ देता है.

**ऑफ़लाइन दृश्‍य** - किनारा उपकरण, हवाई-गित नेटवर्क, विनियमित वातावरण. फ्रेमवर्क इंटरनेट पहुँच और बादल सेवाओं का विचार करता है.

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

आपके वातावरण को जितना अधिक प्रभावित किया जाता है उतना ज़्यादा आप सुस्पष्ट नियंत्रण चाहते हैं ।

## जब मैं लैंगाइन इस्तेमाल करेंगे

आलोचकों के लिए: वहाँ वैध मामले हैं जहाँ मैं LCachain के लिए पहुँच जाएगा।

**हंगेर्स** - सामग्री को निर्माण करने की गति.

**दूर भागें** - यदि आप किसी विचार को जायज़ कर रहे हैं और उत्पादन के लिए फिर से फिर से लिखने की योजना बना रहे हैं.

**पायथन- रंगीन टीम** - अगर आपकी टीम पहले से ही पायथन में कुशल है, तो पर्यावरण फिट मजबूत है.

**सिखाने की धारणाएँ** - LCakain एक बदमाश की मदद कर सकता है अपने खुद का निर्माण करने से पहले एजेंट पैटर्न समझ सकता है.

वे जानते हैं कि कब **नहीं** इसे इस्तेमाल करने के लिए किसी चीज़ का इस्तेमाल करना अनमोल है ।

## पहला सिद्धांत:

यह वास्तव में LCaphain के बारे में नहीं है. यह फ्रेमवर्क और पहली इप्रयोगीय इंजीनियरिंग के बीच व्यापार समाप्त के बारे में है.

फ्रेमवर्क तेजी से जानकारी की समस्या है. यदि आप 100 वींD API निर्माण कर रहे हैं, एंटिटी फ्रेमवर्क या sapper के लिए तक पहुँचने के लिए पहुँच. पैटर्न तय कर रहे हैं.

लेकिन हम अभी तक तय नहीं कर रहे हैं। हम नहीं जानते कि क्या "चाइन्स" या "सेसर" सही मानसिक मॉडल हैं। हम अभी भी इसे बाहर कर रहे हैं।

उस वातावरण में, मैं धातु के निकट बनाना पसंद करता हूँ:

- प्रत्यक्ष एपीआई कॉल के द्वारा (L)`OllamaSharp`, खोलेंARAS SKRS
- साफ स्ट्रिंग निर्माण के ज़रिए निर्माण के लिए संकेत दें
- डोमेन विशिष्ट तर्क के द्वारा वैधता
- उद्देश्य से इंजन चलाया जा रहा है ( एसक्यूएल, खोज, आदि.)

मुझे लगता है कि ये सारी चीज़ें कहाँ से बनायी जा सकती हैं ।

Lacakiin एक पागल उन विचारों के लिए स्वच्छ रूप से नक्शा नहीं है. तो मैं इसे इस्तेमाल नहीं करते हैं.

## दूर ले जाएँ

यदि आप एक .NT डेवलपर कर रहे हैं ... ... ... Laggin पर देख और सोच रहे हैं कि "क्या मुझे इसकी ज़रूरत है?", यहाँ मेरा जवाब है:

**आप LCANKS हल की समस्या को हल करने की जरूरत है** - संदर्भ प्रबंधन, उपकरण झटका, तर्क फिर से कोशिश करें, तर्क.

**आप उन्हें हल करने के लिए LCaggin की जरूरत नहीं है** - विशेष रूप से अगर आप सुस्पष्टता, मजबूत टाइपिंग, और जल्दी से अधिक तेजी से निर्माण निर्माण.

मैं इस पर निर्माण सिद्धांत:

**"एलिम कारण. इंजन गणना करता है, अपने आप के लिए तुम्हारा है."**

या अधिक बस:

**"अगर आप समस्या को हल करने के लिए समझते हैं, आप अक्सर फ्रेमवर्क की जरूरत नहीं है."**

मेरे लिए, C#, मजबूत टाइपिंग, प्रत्यक्ष नियंत्रण प्रवाह, और विद्वत्ता पर निर्भर करता है.

आप के लिए, यह अलग हो सकता है. और यह ठीक है.

लक्ष्य केंद्रों से बचने के लिए नहीं है। लक्ष्य है उन्हें सचेत रूप से चुनने के लिए उन्हें क्या वे प्रदान करते हैं और क्या वे लागत।

---


**आगे पढ़ा जा रहा है:**

- [C# में स्थानीय इबराहीम के साथ बड़े सीएसवी फ़ाइलें](/blog/analysing-large-csv-files-with-local-llms) - बिना फ्रेमवर्क के सीएम + एसक्यूएल का एक ठोस उदाहरण
- [वेब अंतर्वस्तु को ला रहा है और विश्लेषण कर रहा है](/blog/fetching-and-analysing-web-content-with-llms) - वेब जाँच और विश्लेषण बिना फ्रेमवर्क के
- [माइक्रोसॉफ़्ट एजेंट फ्रेमवर्क दस्तावेज़ीकरण](https://learn.microsoft.com/en-us/agent-framework/overview/agent-framework-overview) - आधिकारिक माइक्रोसॉफ़्ट एजेंट फ्रेमवर्क के लिए
- [माइक्रोसॉफ़्ट.EAL.](https://devblogs.microsoft.com/dotnet/introducing-microsoft-extensions-ai-preview/) - आधारित एआई एक वेश्या के लिए.
- [जेनिक कर्नेल](https://github.com/microsoft/semantic-kernel) - Microsoft 'LLLMapontack SKRS
- [लाकंहान दस्तावेज़ीकरण](https://python.langchain.com/) - आप का उपयोग करने के लिए चुन रहे हैं क्या समझने के लिए
- [पहाड़ों को ठोस करता है](https://github.com/awaescher/OllamaSharp) - C# ग्राहक स्थानीय एनएमपीएम के लिए