C# में स्थानीय LLLLM के साथ बड़े सीएसवी फ़ाइलें का विश्लेषण कैसे करें (हिन्दी (Hindi))

SIL: 2 का डाटा - भाग 1 के लिए स्थानीय

ये गलती है हर कोई करता है, वे एक लीओएम में अपनी सीएसवी फ़ीड करने की कोशिश करते हैं. मत करो. TLMELTENTies उत्पन्न करना चाहिए, डाटा नहीं खाते.

आप एक 500MB सीएसवी फ़ाइल मिल गया है और पूछने के लिए चाहते हैं कि "देश के द्वारा औसत अनुक्रम मूल्य क्या है?" औज़ार जैसे कि उत्कृष्ट रूप से सह पायलट अगर आपको खुद पर भरोसा करना है, तो आप क्या कर सकते हैं?

यह लेख आपको बताता है कि कैसे स्थानीय, अकेले में, सी# में ।

एसक्यूएल फ़ाइलों को सीधे क्वैरी करने के लिए DDDB का उपयोग करें. एसक्यूएल फ़ाइलों का उपयोग करें.

किसी कैंची के लिए, अधिक क्लिक किए गए उपचार के लिए जो कि ब्लूएम इंटरफेस का उपयोग करने पर विस्तार करता है (और इन विचारों को लागू करने के लिए एक पूर्ण औजार इन विचारों, सुरक्षित एसक्यूएल मोड, ट्रेसी और बहाव को लागू करता है), मित्र लेख के लिए देखें: डाटाफ्ल्जर: तीव्र स्थानीय डाटा छैतिज पैमाना - विशेष रूप से भाग " कुंजी अद्यतन: सांख्यिकी के रूप में इंटरफेस." इन दो लेखों व्यावहारिक रूप से स्थानीय एमएम + क्वैरी पैटर्न पर एक छोटी सी श्रृंखला बनाता है.

कोर इंसाइट ऑन द स्क्रिप्चर्स

एक डेटा स्टोर के रूप में एक डेटा स्टोर का उपयोग किया जा रहा है गलत रूप में.LM एक औसत - कि वे क्या के लिए कर रहे हैं की गणना करने के लिए लाखों की बुनियादी रूप से सक्षम कर रहे हैं. एक 200 के लिए नहीं है कि वे क्या कर रहे हैं. एक 200K टोकन के संदर्भ में शायद 50,000 लाइन के बराबर है. अपने 500MBONONONT है लाखों.

सही पैटर्न: TLM कारण, डाटाबेस की गणना.

flowchart LR
    A[User Question] --> B[LLM]
    B --> C[SQL Query]
    C --> D[DuckDB]
    D --> E[Results]
    
    style B stroke:#333,stroke-width:4px
    style D stroke:#333,stroke-width:4px

ध्यान दीजिए कि क्या हो रहा है: DLM आपके प्रश्न और स्कीमा पर एक एसक्यूएल क्वैरी बनाता है. DDB इसे वास्तविक डेटा के खिलाफ चलाता है.

प्रोफाइल इंटरफेस के रूप में इलाज करने पर अधिक पर अधिक के लिए (और एक ठोस क्लीगआई) है जो कि प्रोफाइल-यू, सुरक्षित एसक्यूएल क्यू-बैक, रजिस्ट्री-चित सत्रों तथा कैंची के लिए देखें) डाटाफ्ल्जर: तीव्र स्थानीय डाटा छैतिज पैमाना.

क्यों न इसे स्मरण में रखें?

स्पष्ट रूप से सभी एक ही घातक त्रुटि में भाग लेते हैं:

केवीव मददर / डाटा- ताला: पूरी फाइल को रैम में लोड करें. एक 500MB संपर्क वस्तुओं के 2-4GB हो जाता है. एक 5GB फ़ाइल? OOM क्रैश.

वुल्फहाउंड / एसक्यूएल: धीमी गति से आयात चरण (बड़ा फ़ाइलों के लिए), फ़ैक्ट स्कीमा परिभाषाएँ, और डाटाबेस प्रबंधन के लिए आवश्यक है.

पेन्सिलिया: अब भी स्मरण में सब कुछ लोड हो गया है. प्लस, ELLLM-RIM- इम्यूरेक्ट्ड कोड चलाने से सुरक्षा के लिए खतरा है - एसक्यूएल डीक्लास और सेबच्येबल है, पायथन नहीं है.

क्यों duDB

dkDB भिन्न है. यह विस्तारित सीएसवी फ़ाइलों में आयात किया गया है. सीधे - कोई आयात कदम नहीं, स्मृति में कोई लोड नहीं:

using var connection = new DuckDBConnection("DataSource=:memory:");
connection.Open();
using var cmd = connection.CreateCommand();
cmd.CommandText = "SELECT Region, SUM(Amount) FROM 'sales.csv' GROUP BY Region";
// Executes directly against the file - no import, no memory explosion

हत्यारा गुण: यह तालिका के रूप में फ़ाइलों को व्यवहार करता है. बिंदु यह CSV, पार्क, या JSON फ़ाइल पर है और तत्काल प्रश्न. कोई व्यापक खर्च, कोई इंतजार नहीं.

कारक Csver Csver Dvivius DCOGY |--------|-----------|--------|--------| | मेमोरी लोड करता है %s के दौरान संपूर्ण फाइल लोड करता है डिस्क रहता है | सेटअप INVEN स्कीमा स्कीमा + आयात कुछ नहीं करता है | 500MB फ़ाइल libburn ~2GB रैम ढेरों मिनटों को आयात करने के लिए | 5GB फ़ाइल सेंटीमीटर OOM क्रैश बहुत धीमी गति से बढ़िया काम करता है | पार्क एनटीएलएमनो नहीं (10- 100x तेजी से)

DckDB है कि वास्तव में इस मामले का उपयोग करने के लिए डेटा इंजीनियरों का क्या प्रयोग करते हैं. .नेटट बाइंडिंग आपको पूरा Axox.ET समर्थन दे - यह किसी अन्य डाटाबेस की तरह लगता है, सिवाय आप फ़ाइलों को क्वैरी कर रहे हैं.

स्टैक

खुदा ने फरमाया है ना, यह कैसे हो सकता है? |-----------|--------------| | dkDB SpamAssassin क्वाटर सीधे आयात नहीं किया जा सकता है, कोई आयात नहीं किया जा सकता | डी- बस.नेट. सारा AVEL.ELT समर्थन, अपने आप को महसूस करता है | ओलमाjapan. kgm इंच, न तो एपीआई कुंजियों, न ही बादल की कोई रौशनीweather forecast | बोउस किसी भी पैमाने पर वास्तविक जांच डाटा | qwen2.5-coder:7b 7B आकार के आधार पर CSV बढ़िया एसक्यूएल सटीकता

सुरक्षा पर टिप्पणी: हम कर रहे हैं WLLM-एल-रेड एसक्यूएल को चलाने के लिए. यह मनमाना कोड से सुरक्षित है, लेकिन अभी भी वैध की आवश्यकता है. देखें देखें. सुरक्षा खंड सुरक्षित रखने के लिए. प्रोफाइल को बदलने पर विस्तृत चर्चा के लिए और इन पैटर्नों को लागू करता है कि एक क्लिक करने के लिए, साथी टुकड़ा देखें डाटाफ्ल्जर: तीव्र स्थानीय डाटा छैतिज पैमाना.

परियोजना सेटअप

चलो एक नमूना प्रोजेक्ट बनाएं. Nuo पैकेज संस्थापित करें:

dotnet add package DuckDB.NET.Data.Full
dotnet add package OllamaSharp
dotnet add package Bogus

कि एसक्यूएल में अच्छा है कि एक कोडिंग मॉडल खींच लें:

ollama pull qwen2.5-coder:7b

यु. पू.

यहाँ है कि कैसे टुकड़े एक साथ फिट है:

flowchart TB
    subgraph Input
        Q[User Question]
        CSV[CSV File]
    end
    
    subgraph Processing
        Schema[Extract Schema]
        Sample[Get Sample Rows]
        Context[Build LLM Context]
        LLM[Generate SQL]
        Validate[Validate SQL]
        Execute[Execute Query]
    end
    
    subgraph Output
        Results[Query Results]
    end
    
    CSV --> Schema
    CSV --> Sample
    Schema --> Context
    Sample --> Context
    Q --> Context
    Context --> LLM
    LLM --> Validate
    Validate -->|Error| LLM
    Validate -->|OK| Execute
    CSV --> Execute
    Execute --> Results
    
    style LLM stroke:#333,stroke-width:4px
    style Execute stroke:#333,stroke-width:4px

मुख्य अन्तर्दृष्टि: हम वोलएम देते हैं स्कीमा तथा नमूना डाटा, वास्तविक डेटा नहीं. यह संदर्भ छोटे और जवाब तेजी से रहता है.

ऐसा क्यों?: LLLM मूल्यांकन उत्पन्‍न करता है ( एसक्यूएल). DakB यह चलाने से पहले वैध चरण त्रुटियों को उत्पन्न करता है. पुनः कोशिश करें लूप गलती करता है कभी कभी कभी गलती करता है. यह अलगाव प्रणाली को सुरक्षित और सही बनाता है. एक विस्तृत विस्तृत विवरण के लिए क्लिक करें (जैसे प्रोफ़ाइल-पहले और सुरक्षित चलाने की सीमाएं) डाटाफ्ल्जर: तीव्र स्थानीय डाटा छैतिज पैमाना.

चरण 1: बोउस के साथ जांच डाटा उत्पन्न करें

पहले से ही सीएसवी डाटा है? करने के लिए छोड़ें चरण 2: स्कीमा संदर्भ निर्माण करें.

इससे पहले कि हम अपनी RLLLCONCONT की जाँच कर सकते हैं, हम डेटा का विश्लेषण करने के लिए की जरूरत है. विकास और परीक्षण के लिए, वैज्ञानिक डेटा असली डेटा को हरा देता है:

जाँच का आकार बदलें - 100K, 1M, या 10M पंक्ति बनाएँ ताकि भिन्न आकार में प्रदर्शन की जांच कर सकें
गोपनीयता - डेमो या स्क्रीनशॉट में वास्तविक ग्राहक/ व्यावसायिक डाटा भेजने का कोई जोखिम नहीं
पतनशीलता - एक ही बीज = एक ही डेटा, बग रीफ्रेक्ट किया जा रहा है
किनारा मामलों - वितरण को नियंत्रित करता है (जैसे, बल 5% लौटाता है, विशेष तिथि सीमा सीमा)

बोउस क्या है?

बोउस लोकप्रिय नकली लाइब्रेरी का .NENT पोर्ट है. यह वास्तविक रूप से नक़ली डेटा नाम, ईमेल, संख्या - सही स्थानीय समर्थन के साथ उत्पन्न करता है. हाथ का परीक्षण फ़ाइलों या बेतरतीब कचरा डेटा का उपयोग करने के बजाय, बोउच आपको डेटा देता है कि जानकारी देता है रूप वास्तविक:

f.Name.FullName() QX "जान्स स्मिथ" (सामान्यतः "df1234" नहीं)
f.Internet.Email() BAR वाल्व@gmail.com" (गलत रूप से प्रारूपित)
f.Date.Between(start, end) ईएक्सटीसी तिथि वितरण
f.Commerce.ProductName() ✔ "Howandd ग्रीय ग्रीनी चीज़" (फॉन, लेकिन फिर बंद करने योग्य)

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

डाटा मॉडल पारिभाषित करें

internal class SaleRecord
{
    public string OrderId { get; set; } = "";
    public DateTime OrderDate { get; set; }
    public string CustomerId { get; set; } = "";
    public string CustomerName { get; set; } = "";
    public string Region { get; set; } = "";
    public string Category { get; set; } = "";
    public string ProductName { get; set; } = "";
    public int Quantity { get; set; }
    public decimal UnitPrice { get; set; }
    public decimal Discount { get; set; }
    public bool IsReturned { get; set; }
}

नक़ली संदेश कॉन्फ़िगर करेंName

Bougs पीढ़ी के नियमों को पारिभाषित करने के लिए एक कुशल एपीआई का उपयोग करता है:

var categories = new[] { "Electronics", "Clothing", "Home & Garden", "Sports", "Books" };
var regions = new[] { "North", "South", "East", "West", "Central" };

var faker = new Faker<SaleRecord>()
    .RuleFor(s => s.OrderId, f => f.Random.Guid().ToString()[..8].ToUpper())
    .RuleFor(s => s.OrderDate, f => f.Date.Between(
        new DateTime(2022, 1, 1), 
        new DateTime(2024, 12, 31)))
    .RuleFor(s => s.CustomerId, f => $"CUST-{f.Random.Number(10000, 99999)}")
    .RuleFor(s => s.CustomerName, f => f.Name.FullName())
    .RuleFor(s => s.Region, f => f.PickRandom(regions))
    .RuleFor(s => s.Category, f => f.PickRandom(categories))
    .RuleFor(s => s.ProductName, (f, s) => GenerateProductName(f, s.Category))
    .RuleFor(s => s.Quantity, f => f.Random.Number(1, 20))
    .RuleFor(s => s.UnitPrice, f => f.Random.Decimal(9.99m, 299.99m))
    .RuleFor(s => s.Discount, f => f.Random.Bool(0.3f) ? f.Random.Decimal(0.05m, 0.25m) : 0m)
    .RuleFor(s => s.IsReturned, f => f.Random.Bool(0.05f));

चलो नीचे गिर क्या हो रहा है:

f (फाउंड) - सभी डाटा मॉड्यूल में पहुँच के लिए जेनरेटर उदाहरण (जैसे, तिथि, बेतरतीब, आदि.)
f.Random.Guid().ToString()[..8] - एक जीयूआई बनाया लेकिन पढ़ने योग्य अनुक्रम आईडी के लिए केवल पहले 8 अक्षर ले लो
f.Date.Between() - सटीक सीमा के भीतर बेतरतीब तारीख़ ( वर्ष 9999)
f.PickRandom(array) पूर्व पारिभाषित विकल्पों से बेतरतीब चुनें (अनुप्रयोगात्मक वर्गों)
f.Random.Bool(0.3f) - सही का 30% मौका (30% के आदेशों का एक कड़ी प्राप्त करें)
(f, s) सिंटेक्स - थोड़ी देर के लिए दोनों नकली रिकॉर्ड पर पहुँच जाएँ। ProductName पर निर्भर करें Category

वह (f, s) पैटर्न शक्तिशाली है - इसका मतलब है "प्रयोग" आदेशों को इलेक्ट्रॉनिक उत्पादों के नाम मिलता है, बेतरतीब वस्तुओं के नाम नहीं. यह शक्ति उत्पन्न डेटा अधिक संभव बनाता है एक वर्ग द्वारा "Asegugugide" की तरह जाँच करने के लिए।

CSV में लिखें तथा लिखें

var records = faker.Generate(100_000); // Adjust for your testing needs

await using var writer = new StreamWriter(csvPath, false, Encoding.UTF8);
await writer.WriteLineAsync("OrderId,OrderDate,CustomerId,CustomerName,Region,Category,...");

foreach (var record in records)
{
    var total = record.Quantity * record.UnitPrice * (1 - record.Discount);
    await writer.WriteLineAsync($"{record.OrderId},{record.OrderDate:yyyy-MM-dd},...");
}

100K पंक्तियाँ 23MB - जाँच के बारे में काफी हद तक आयात करती हैं, लेकिन आप आसानी से लाखों लोगों के लिए स्केल कर सकते हैं. यह पीढ़ी तेजी से 100K पंक्तियों के लिए तेज है क्योंकि बोईस बड़ी पीढ़ी के लिए अधिकतम किया जाता है.

आकार बदलें: सेट Randomizer.Seed = new Random(12345) फिर से व्यवस्थित डाटा प्राप्त करने से पहले. एक ही बीज = एक ही बार "अनुभिक" रिकॉर्ड, जो कि डिबगिंग के लिए अमूल्य है.

चरण 2: स्कीमा संदर्भ निर्माण करें

DLM एसक्यूएल बनाने से पहले, इसे डाटा संरचना समझने की आवश्यकता है. हम इसे DetDB से निकालते हैं:

संदर्भ मॉडल

public class DataContext
{
    public string CsvPath { get; set; } = "";
    public List<ColumnInfo> Columns { get; set; } = new();
    public List<Dictionary<string, string>> SampleRows { get; set; } = new();
    public long RowCount { get; set; }
}

public class ColumnInfo
{
    public string Name { get; set; } = "";
    public string Type { get; set; } = "";  // VARCHAR, DOUBLE, TIMESTAMP, etc.
}

यह सब कुछ ले लेता है: स्तम्भ के नाम, प्रकार, और कुछ नमूना लाइन जो डाटा फ़ॉर्मेट को समझने के लिए है.

योजना निकाल रहे

DBDB का वर्णन बिना सभी लोड किए कोई सीएसवी का वर्णन कर सकता है:

private DataContext BuildContext(DuckDBConnection connection, string csvPath)
{
    var context = new DataContext { CsvPath = csvPath };

    // Get schema - DuckDB infers types from the CSV
    using var cmd = connection.CreateCommand();
    cmd.CommandText = $"DESCRIBE SELECT * FROM '{csvPath}'";
    using var reader = cmd.ExecuteReader();

    while (reader.Read())
    {
        context.Columns.Add(new ColumnInfo
        {
            Name = reader.GetString(0),  // Column name
            Type = reader.GetString(1)   // Inferred type
        });
    }

    return context;
}

वह DESCRIBE कमांड केवल फ़ाइल हेडर को पढ़ने के लिए कुछ पंक्तियाँ भी रखता है - यह बहुत बड़ी फ़ाइलों पर भी तत्काल है.

सेंपल डाटा प्राप्त किया जा रहा है

सेंपल पंक्तियों को डाटा फॉर्मेटों को समझने में मदद करता है (तिथि, आईडी, आदि):

using var cmd = connection.CreateCommand();
cmd.CommandText = $"SELECT * FROM '{csvPath}' LIMIT 3";
using var reader = cmd.ExecuteReader();

while (reader.Read())
{
    var row = new Dictionary<string, string>();
    for (int i = 0; i < reader.FieldCount; i++)
    {
        var value = reader.IsDBNull(i) ? "NULL" : reader.GetValue(i)?.ToString() ?? "";
        row[reader.GetName(i)] = value;
    }
    context.SampleRows.Add(row);
}

तीन पंक्‍तियाँ आम तौर पर काफ़ी होती हैं - यह दिखाता है कि कौन - सी चीजें व्यर्थ चिन्हों की अपेक्षा करती हैं ।

चरण 3: एसक्यूएल को सीएल के साथ बनाएँ

यह मुश्किल हिस्सा है. यहाँ कठोर नियमों के बिना, स्थानीय नियम के बिना, स्थानीय LLLM जटिल लेकिन टूटी हुई एसक्यूएल उत्पन्न होगी. लक्ष्य है ज्ञानवाद, अप्रयोग नहीं है.

संकेत का निर्माण

private string BuildPrompt(DataContext context, string question, string? previousError)
{
    var sb = new StringBuilder();

    sb.AppendLine("You are a SQL expert. Generate a DuckDB SQL query to answer the user's question.");
    sb.AppendLine();
    sb.AppendLine("IMPORTANT RULES:");
    sb.AppendLine("1. The table is accessed directly from the CSV file path");
    sb.AppendLine("2. Use single quotes around the file path in FROM clause");
    sb.AppendLine("3. DuckDB syntax - use LIMIT not TOP, use || for string concat");
    sb.AppendLine("4. Return ONLY the SQL query, no explanation, no markdown");
    sb.AppendLine();
    
    sb.AppendLine($"CSV File: '{context.CsvPath}'");
    sb.AppendLine($"Row Count: {context.RowCount:N0}");
    sb.AppendLine();
    
    // Schema
    sb.AppendLine("Schema:");
    foreach (var col in context.Columns)
    {
        sb.AppendLine($"  - {col.Name}: {col.Type}");
    }

नियम निर्णायक है - यह बताता है कि कैसे DDB के लिए क्वैरी को ठीक से फ़ॉर्मेट करें.

सेंपल डाटा जोड़ा जा रहा है

    if (context.SampleRows.Count > 0)
    {
        sb.AppendLine();
        sb.AppendLine("Sample data (first 3 rows):");
        foreach (var row in context.SampleRows)
        {
            var values = row.Select(kv => $"{kv.Key}='{kv.Value}'");
            sb.AppendLine($"  {{{string.Join(", ", values)}}}");
        }
    }

त्रुटि रिकवरी

यदि पिछली कोशिश असफल हुई तो त्रुटि शामिल है:

    if (previousError != null)
    {
        sb.AppendLine();
        sb.AppendLine("YOUR PREVIOUS QUERY HAD AN ERROR:");
        sb.AppendLine(previousError);
        sb.AppendLine("Please fix the query based on this error.");
    }

    sb.AppendLine();
    sb.AppendLine($"Question: {question}");
    sb.AppendLine();
    sb.AppendLine("SQL Query (no markdown, no explanation):");

    return sb.ToString();
}

यह कोशिश करना ज़रूरी है - स्थानीय LLLM कभी कभी कभी-कभी वाक्यों को गलत बना देता है, और उन्हें गलती आम तौर पर दूसरे प्रयास में सुधार देता है.

लेगएम को बुलाया जा रहा है

var request = new GenerateRequest { Model = _model, Prompt = prompt };
var response = await _ollama.GenerateAsync(request).StreamToEndAsync();
var sql = CleanSqlResponse(response?.Response ?? "");

वह StreamToEndAsync() पूरी प्रतिक्रिया के लिए प्रतीक्षा करता है. एक बेहतर यूएक्स के लिए, आप चिन्ह खोल सकते हैं जब वे आते हैं.

प्रतिक्रिया साफ करना

द्वारा बताया गया है के बावजूद कार्ड अकसर एसक्यूएल को नीचे दिए गए कोड ब्लॉक में लपेटता है:

private string CleanSqlResponse(string response)
{
    var sql = response.Trim();

    // Remove markdown code blocks if present
    if (sql.StartsWith("```"))
    {
        var lines = sql.Split('\n').ToList();
        lines.RemoveAt(0);  // Remove opening ```sql
        if (lines.Count > 0 && lines[^1].Trim().StartsWith("```"))
        {
            lines.RemoveAt(lines.Count - 1);  // Remove closing ```
        }
        sql = string.Join('\n', lines);
    }

    return sql.Trim('`', ' ', '\n', '\r');
}

चलाने से पहले चरण 4:

DkDB' EXPLAIN क्वैरी चल रहे बगैर एसक्यूएल सिंटेक्स को जाँचें:

private string? ValidateSql(DuckDBConnection connection, string sql)
{
    try
    {
        using var cmd = connection.CreateCommand();
        cmd.CommandText = $"EXPLAIN {sql}";
        cmd.ExecuteNonQuery();
        return null; // Valid
    }
    catch (Exception ex)
    {
        return ex.Message;
    }
}

यदि वैधीकरण असफल, तो हम त्रुटि को वोलएम में वापस खिलाते हैं और फिर कोशिश करते हैं (क्या सीमा तक).

चरण 5: निष्पादित तथा फ़ॉर्मेट परिणाम

अंत में, क्वैरी चलाएँ तथा आउटपुट को फ़ॉर्मेट करें:

private QueryResult ExecuteQuery(DuckDBConnection connection, string sql)
{
    var result = new QueryResult { Sql = sql };

    try
    {
        using var cmd = connection.CreateCommand();
        cmd.CommandText = sql;
        using var reader = cmd.ExecuteReader();

        // Capture column names
        for (int i = 0; i < reader.FieldCount; i++)
        {
            result.Columns.Add(reader.GetName(i));
        }

        // Capture rows
        while (reader.Read())
        {
            var row = new List<object?>();
            for (int i = 0; i < reader.FieldCount; i++)
            {
                row.Add(reader.IsDBNull(i) ? null : reader.GetValue(i));
            }
            result.Rows.Add(row);
        }

        result.Success = true;
    }
    catch (Exception ex)
    {
        result.Success = false;
        result.Error = ex.Message;
    }

    return result;
}

वह QueryResult वर्ग ( नमूना परियोजना में पूरा दिखाया गया है) में शामिल है ToString() उस विधि से परिणाम मिलते हैं जो पढ़ने लायक तालिका के रूप में परिणाम निकलता है.

वार्तालाप संदर्भ जोड़ रहे

इंटरएक्टिव विश्लेषण के लिए, उपयोक्ता अकसर इन प्रश्नों से पूछना चाहते हैं:

"What's the total revenue?"
→ "Break that down by region"
→ "Show the top 5 regions"

दूसरे और तीसरा सवाल केवल पहले से संदर्भ से समझ लेते हैं ।

ट्रेकिंग इतिहास

public class ConversationTurn
{
    public string Question { get; set; } = "";
    public string Sql { get; set; } = "";
    public bool Success { get; set; }
    public int RowCount { get; set; }
    public string Summary { get; set; } = "";  // "Single value: 1234567.89"
}

संकेतों में इतिहास हिस्सा लेते हुए

if (_history.Count > 0)
{
    sb.AppendLine();
    sb.AppendLine("CONVERSATION HISTORY (for context):");
    
    foreach (var turn in _history.TakeLast(5))  // Last 5 turns
    {
        sb.AppendLine($"Q: {turn.Question}");
        sb.AppendLine($"SQL: {turn.Sql}");
        if (turn.Success)
        {
            sb.AppendLine($"Result: {turn.Summary}");
        }
        sb.AppendLine();
    }
}

इतिहास संदर्भों को "कि", "उन परिणाम" के रूप में समझने के लिए संदर्भ देता है, या "वह बंद कर दिया है.

कौन सा मॉडल इस्तेमाल करने के लिए?

एसक्यूएल पीढ़ी के लिए, कोडिंग मॉडल उत्तम हैं. यहां उपलब्ध विकल्प हैं ओसमा का मॉडल लाइब्रेरी:

अतुल्यकालिक मॉडल लानत गति इससे बाहर हो गया

-------	------	-------	---------	------
`deepseek-coder-v2:16b` छावनी 9GBcolor- दुआएँ बढ़िया मध्यम ओलमाjapan. kgm
`codellama:7b` रहता है 4GB रौशनी फास्ट / घड़क ओलमाjapan. kgm
`llama3.2:3b` IMTAT 2GBGB बहुत तेज CHARTKS बहुत तेज स्वीकार करता है ओलमाjapan. kgm

अधिकांश उपयोग के लिए, qwen2.5-coder:7b प्यारी जगह - सही एसक्यूएल, बढ़िया गति, मामूली हार्डवेयर (8GB+ रैम) पर दौड़ता है ।

परफार्मेंस

वास्तविक विश्वव्यापी बेचमार्क्स

100K पंक्ति सीएसवी फ़ाइल पर जाँच की जा रही है (14MB) एक मानक dev मशीन पर (Ryy WVD, 32GB रैम):

अतुल्यकालिक क्वैरी क़िस्म (_m) |------------|------| SMTP सादा उन 65msmahjongg map name SUMIF 58-68ms के साथ सुरक्षित WILELCT 63ms के साथ विस्तार HAVC 71ms के साथ metacuUP

किसी भी चरण पर 100K - पर एक प्रकार की जांच के लिए सब कुछ बिना आयात किए. जटिल मामलों को हिसाब की गिनती से अधिक जटिल रूप से क्वैरी करें, DDDB के स्तम्भर इंजन किसी भी आकार के बिना निश्चित रूप से काम करता है.

ऊपर की ओर से बड़ी फ़ाइलों को परिवर्तित करें

1GB से अधिक फ़ाइलों के लिए, पार्क फ़ॉर्मेट 10- 100x तेजी से है:

using var cmd = connection.CreateCommand();
cmd.CommandText = $"COPY (SELECT * FROM '{csvPath}') TO '{parquetPath}' (FORMAT PARQUET)";
cmd.ExecuteNonQuery();

संपीडित पार्क फ़ाइल भी बहुत छोटा है.

सुरक्षा विचार

जब सम्मिलित किया जाता है तो एसक्यूएल को चलाया जाता है:

private bool IsSafeQuery(string sql)
{
    var dangerous = new[] { "DROP", "DELETE", "TRUNCATE", "UPDATE", "INSERT", "ALTER", "CREATE" };
    var upperSql = sql.ToUpperInvariant();
    return !dangerous.Any(d => upperSql.Contains(d));
}

DackDB के मध्य भी प्राकृतिक अकेलेपन प्रदान करता है - यह अपने उत्पादन डाटाबेस को प्रभावित नहीं कर सकता.

पूर्ण उदाहरण

यह सब एक साथ आता है कैसे है:

// Generate test data
await GenerateSalesCsvAsync("sales.csv", 100_000);

// Simple query
using var service = new CsvQueryService("qwen2.5-coder:7b", verbose: true);
var result = await service.QueryAsync("sales.csv", "What are total sales by region?");
Console.WriteLine(result);

// Conversational analysis
using var analyser = new ConversationalCsvAnalyser("sales.csv", "qwen2.5-coder:7b");

Console.WriteLine(await analyser.AskAsync("What's the total revenue?"));
Console.WriteLine(await analyser.AskAsync("Break that down by category"));
Console.WriteLine(await analyser.AskAsync("Which category has the most returns?"));

सारांश

रखने के लिए मानसिक मॉडल: BLLM कारण; डाटाबेस की गणना.

ईएलएम को डाटा नहीं खिलाते. स्कीमा यह फीडता है, यह एसक्यूएल उत्पन्न करता है, कि एसक्यूएल को सही क्वैरी इंजन के खिलाफ चलता है. यह अलगाव क्यों पैमाने पर काम करता है.

कार्यान्वयन:

dkDB ओर्स सीधे - कोई आयात नहीं, डिस्क से नदियां
स्कीमा + नमूने डाटा का पता लगाने के बिना कार्ड के पर्याप्त संदर्भ दे
सख्त प्राम्प्ट नियम बल्ड एसक्यूएल का पता लगाने के लिए, सृजनात्मक विकास नहीं
ई. एल. एल. चलाने से पहले प्रतीत होता है
त्रुटि फ़ीडबैक सहित फिर से कोशिश करें कभी- कभी सिंटेक्स गिरता है

परिणाम: पूरी तरह से ऑफ़लाइन, पूरी तरह से ऑफ़लाइन फ़ाइलों के साथ कि आपके मशीन को कभी नहीं छोड़ता।

पूरा नमूना परियोजना उपलब्ध है लगभग सा.सी.सी. - शामिल CsvQueryService, ConversationalCsvAnalyser, तथा बो- आधारित डाटा पीढ़ी.

संसाधन

dkDB

duDB दस्तावेज़ीकरण - पूरा संदर्भ
DBX आयात - सीएसवी विशिष्ट विशेषताएँ
एसक्यूएल एसक्यूएल संदर्भ - एसक्यूएल सिंटेक्स भिन्नता अन्य डाटाबेस से
DakD. net Git Gib - C# बाइंडिंग
डी- बस. एन. - स्थानीय बाइनरी के साथ पूरा पैकेज

ओलमा तथा ऐनएम्स

ओलमाjapan. kgm - स्थानीयLLM बंद
ओलमा मॉडल लाइब्रेरी - उपलब्ध मॉडल
पहाड़ों को ठोस करता है - C# क्लाएंट लाइब्रेरी
ओलमा स्यू मिल

जांच डाटा बनाने का कार्य

बोउस "%s" - नक़ली डाटा जेनरेटर
बोउस API संदर्भ - उपलब्ध डाटा क़िस्म

वैकल्पिक उल्लेख

केवीव मददर - सीएसवी पारसिंग लाइब्रेरी
माइक्रोसॉफ़्ट.डा. ए. - वेनॉट के लिए डाटाफ़म
पेन्सिलिया - पायथन एमएम + पांडा संयोजन