# C# में स्थानीय LLMs के साथ बड़े सीएसवी फ़ाइलों का विश्लेषण कैसे करें
2025-12-18T10:00
**श्रेणी: डाटा के लिए स्थानीय एलएलएम - भाग 1 का**
यह गलती हर कोई करता है। वे अपने सीएसवी को एलएलएम में भरने की कोशिश करते हैं **LLMs को क्वेरी उत्पन्न करना चाहिए**
आप के पास एक 500MB CSV फ़ाइल है और पूछना चाहते हैं [एक्सेल में सह-पाइलोट](https://support.microsoft.com/en-gb/copilot-excel) यह कर सकता है, लेकिन क्या यदि आपका डेटा क्लाऊड सेवाओं के लिए बहुत संवेदनशील है
यह अनुच्छेद आपको दिखाता है कि कैसे C में - स्थानीय रूप से, निजी रूप से
> सीएसवी फ़ाइलों को सीधे क्वेरी करने के लिए DuckDB का उपयोग करें
एक अनुपूरक के लिए , अधिक CLI- फोकस उपचार जो LLM इंटरफेस के रूप में सांख्यिकी प्रोफाइलों का उपयोग करने पर विस्तार करता है और इन विचारों को लागू करने की पूरी उपकरण दिखाता है। **[डेटासममारीजर: त्वरित स्थानीय डाटा प्रोफ़ाइलिंग](/blog/datasummarizer-how-it-works)** विशेष रूप से अनुभाग "Key Upgrade
[TOC]
## कोर इंस्टीट्यूट
डेटा भंडार के रूप में LLM का उपयोग गलत आकलन है।
सही पैटर्न **LLM कारण**
```mermaid
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
```
क्या हो रहा है ध्यान दें? LLM आपके प्रश्न और स्कीमा पर आधारित एक एसक्यूएल क्वेरी उत्पन्न करता है.
LLM अंतरफलक के रूप में प्रोफाइलों का व्यवहार करने पर अधिक जानकारी के लिए (और एक ठोस सीएलआई जो प्रोफ़ाइल को लागू करता है। **[डेटासममारीजर: त्वरित स्थानीय डाटा प्रोफ़ाइलिंग](/blog/datasummarizer-how-it-works#the-key-upgrade-statistics-as-the-interface)**.
## इसे सिर्फ मेमोरी में लोड क्यों नहीं करें
स्पष्ट दृष्टिकोणों में सभी एक ही घातक दोष है
**[सीएसवीHelperComment](https://joshclose.github.io/CsvHelper/) डाटाफ्रेम**: संपूर्ण फ़ाइल को RAM में लोड करें
**SQLite / PostgreSQL**: एक धीमी आयात चरण की आवश्यकता होती है
**[पांडसAI](https://github.com/Sinaptik-AI/pandas-ai)**अभी भी सब कुछ स्मृति में लोड करता है
## क्यों डकडीबी
[डक डीबी](https://duckdb.org/) भिन्न है. यह सीएसवी फ़ाइलों की पूछताछ करता है *सीधा* आयात चरण नहीं है
```csharp
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
```
घातक विशेषता **यह फ़ाइलों को तालिका के रूप में व्यवहार करता है**. इसे सीएसवी पर चिह्नित करें।
फ़ैक्टर | CsvHelper
|--------|-----------|--------|--------|
| **स्मृति** पूरे फ़ाइल को लोड करता है
| **सेटअप** | कोई भी नहीं | योजना | + | आयात
| **500MB फाइल** आयात करने के लिए मिनट
| **5GB फ़ाइल** | OOM क्रैश
| **पर्किट** | नहीं
डकडीबी है क्या डेटा इंजिनियर्स पाइथोन में इस उपयोग के लिए उपयोग करते हैं [.NET बाइंडिंग](https://github.com/Giorgi/DuckDB.NET) आप को पूरा ADO देता है
## स्टैक
घटक
|-----------|--------------|
| [डक डीबी](https://duckdb.org/) क्वेरी सीएसवी सीधे
| [डकडीबी](https://github.com/Giorgi/DuckDB.NET) पूर्ण ADO
| [ओलामाCity name (optional, probably does not need a translation)](https://ollama.ai/) | स्थानीय अनुमान
| [बोगस](https://github.com/bchavez/Bogus) किसी भी पैमाने पर वास्तविक परीक्षण डेटा
| [`qwen2.5-coder:7b`](https://ollama.ai/library/qwen2.5-coder) सबसे अच्छा SQL सटीकता 7B आकार में
> **सुरक्षा पर नोट**हम LLM को निष्पादित कर रहे हैं [सुरक्षा खंड](#security-considerations) सुरक्षा के लिए. प्रोफाइलों को एलएलएम इंटरफेस में बदलने और इन पैटर्नों को लागू करने वाले सीएलआई के बारे में विस्तृत चर्चा के लिए **[डेटासममारीजर: त्वरित स्थानीय डाटा प्रोफ़ाइलिंग](/blog/datasummarizer-how-it-works)**.
## परियोजना सेटअप
एक नमूना परियोजना बनाएँ
```bash
dotnet add package DuckDB.NET.Data.Full
dotnet add package OllamaSharp
dotnet add package Bogus
```
एक कोडन खींचना
```bash
ollama pull qwen2.5-coder:7b
```
## वास्तुकला
यहाँ यह है कि कैसे टुकड़े एक साथ मिलते हैं
```mermaid
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
```
प्रमुख अंतर्दृष्टि-: हम LLM दे रहे हैं **स्कीमा और नमूना डेटा**वास्तविक डेटा नहीं है
**यह क्यों महत्वपूर्ण है**LLM उद्देश्य उत्पन्न करता है. **[डेटासममारीजर: त्वरित स्थानीय डाटा प्रोफ़ाइलिंग](/blog/datasummarizer-how-it-works#the-key-upgrade-statistics-as-the-interface)**.
## चरण 1: बोग्स के साथ परीक्षण डाटा उत्पन्न करें
> **पहले से ही सीएसवी डाटा है** में जाएँ [चरण 2: योजना संदर्भ बनाएँ](#step-2-build-the-schema-context).
हमारे LLM का परीक्षण करने से पहले हमें विश्लेषण के लिए डेटा की जरूरत है।
1. **मापन परीक्षण** निष्पादन को विभिन्न आकारों पर सत्यापित करने के लिए - उत्पन्न करें
2. **गोपनीयता** - वास्तविक ग्राहक को प्रदर्शित करने की कोई जोखिम नहीं
3. **प्रजननक्षमता** Same seed = same data, making bugs reproducible
4. **किनारा केस** वितरण को नियंत्रित करें
### बोगस क्या है
[बोगस](https://github.com/bchavez/Bogus) एक लोकप्रिय फेकर का नेट पोर्ट है। *दृष्य* वास्तविक:
- `f.Name.FullName()` →
- `f.Internet.Email()` @item: inlistbox Sort By
- `f.Date.Between(start, end)` → वास्तविक तिथि वितरण
- `f.Commerce.ProductName()` → "Handcrafted Granite Cheese
यह महत्वपूर्ण है क्योंकि वास्तविक डेटा आपको समस्याओं को पता लगाने में मदद करता है
### डाटा मॉडल परिभाषित करें
```csharp
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; }
}
```
### फेकर कॉन्फ़िगर करें
निर्माण नियमों को परिभाषित करने के लिए बोगस एक प्रवाहित API का उपयोग करता है
```csharp
var categories = new[] { "Electronics", "Clothing", "Home & Garden", "Sports", "Books" };
var regions = new[] { "North", "South", "East", "West", "Central" };
var faker = new Faker()
.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]`** - एक GUID उत्पन्न करें लेकिन एक पठनीय क्रम आईडी के लिए केवल पहले 8 अक्षर ले लो
- **`f.Date.Between()`** वास्तविक दायरे के भीतर अनियमित तिथि
- **`f.PickRandom(array)`** पूर्वपरिभाषित विकल्पों से अनियमित रूप में चुनें
- **`f.Random.Bool(0.3f)`** सच्चे होने की संभावना
- **`(f, s)` वाक्य-रचना** - दोनों फेकर और आंशिक रूप से अभिगम करता है `ProductName` पर निर्भर `Category`
`(f, s)` पैटर्न शक्तिशाली है - इसका मतलब यह है कि "इलेक्ट्रॉनिक्स" क्रमादेश इलेक्ट्रॉनिक उत्पाद नाम प्राप्त करते हैं
### सीएसवी में उत्पन्न करें और लिखें
```csharp
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},...");
}
```
पंक्तियां लगभग 15MB CSV को उत्पन्न करती हैं।
> **टिप**: सेट `Randomizer.Seed = new Random(12345)` प्रतिपादनीय डेटा प्राप्त करने के लिए उत्पन्न करने से पहले
## चरण 2: योजना संदर्भ बनाएँ
LLM SQL उत्पन्न करने से पहले यह डेटा संरचना को समझने की जरूरत है
### संदर्भ मॉडल
```csharp
public class DataContext
{
public string CsvPath { get; set; } = "";
public List Columns { get; set; } = new();
public List> 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.
}
```
यह सभी LLM की जरूरत है captures
### स्कीमा निकाल रहा है
डकडीबी सभी लोड किए बिना किसी भी सीएसवी का वर्णन कर सकता है
```csharp
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` कमांड सिर्फ फ़ाइल हेडर और कुछ पंक्तियों के लिए प्रकार अनुमान पढ़ता है.
### नमूना डाटा प्राप्त कर रहा है
नमूना पंक्ति LLM को डेटा प्रारूपों को समझने में मदद करती है
```csharp
using var cmd = connection.CreateCommand();
cmd.CommandText = $"SELECT * FROM '{csvPath}' LIMIT 3";
using var reader = cmd.ExecuteReader();
while (reader.Read())
{
var row = new Dictionary();
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);
}
```
तीन पंक्तियां सामान्यतः पर्याप्त है - यह LLM को दिखाता है कि टोकन बर्बाद किए बिना क्या प्रारूपों की आशा करें
## चरण 3: LLM के साथ SQL उत्पन्न करें
**यह कठिन हिस्सा है** यहाँ त्वरित अभियांत्रिकी गैर है।
### द प्रोम्प्ट निर्माण
```csharp
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}");
}
```
नियम अनुभाग महत्वपूर्ण है - यह LLM को यह बताता है कि exactly how to format the query for DuckDB
### नमूना डाटा जोड़ें
```csharp
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)}}}");
}
}
```
### त्रुटि पुनर्प्राप्ति
यदि पिछला प्रयास असफल रहा है, तो त्रुटि शामिल करें
```csharp
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();
}
```
यह पुनः प्रयास प्रक्रिया महत्वपूर्ण है - स्थानीय LLM कभी-कभी वाक्य संरचना त्रुटियाँ करते हैं
### एलएलएम को बुला रहा है
```csharp
var request = new GenerateRequest { Model = _model, Prompt = prompt };
var response = await _ollama.GenerateAsync(request).StreamToEndAsync();
var sql = CleanSqlResponse(response?.Response ?? "");
```
`StreamToEndAsync()` पूरा जवाब की प्रतीक्षा करता है. बेहतर UX के लिए, तुम टोकन को जब वे आ जाते हैं, स्ट्रीम कर सकते थे
### प्रतिक्रिया को साफ करना
LLMs अक्सर मार्कडाउन कोड ब्लॉकों में एसक्यूएल को लपेटते हैं हालांकि उन्हें यह नहीं कहा गया है
```csharp
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: निष्पादन से पहले वैध करें
डकडीबी `EXPLAIN` हमें क्वेरी चलाने के बिना एसक्यूएल वाक्य संरचना जाँच करने देता है
```csharp
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;
}
}
```
यदि सत्यापन असफल होता है तो हम LLM में त्रुटि को फिर से भेजते हैं और एक सीमा तक पुनः प्रयास करें
## चरण 5: निष्पादन और प्रारूप परिणाम
अंत में क्वेरी चलाएँ और आउटपुट को प्रारूपित करें
```csharp
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();
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"
```
दूसरा और तीसरा प्रश्न केवल पहले से संदर्भ के साथ अर्थ रखता है
### वार्तालाप इतिहास ट्रैक कर रहा है
```csharp
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"
}
```
### प्रोम्प्ट में इतिहास सम्मिलित करें
```csharp
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();
}
}
```
इतिहास LLM संदर्भ को इस तरह के संदर्भों को समझने के लिए प्रदान करता है जैसे "that",
## किस मॉडल का उपयोग करना है
एसक्यूएल जनन के लिए, कोडिंग- फोकस मॉडल सबसे अच्छा काम करते हैं [Ollama's मॉडल लाइब्रेरी](https://ollama.ai/library):
मॉडल | | | आकार || | गति & #44; | | गुणवत्ता
|-------|------|-------|---------|------|
| `qwen2.5-coder:7b` | [ओलामाCity name (optional, probably does not need a translation)](https://ollama.ai/library/qwen2.5-coder) |
| `deepseek-coder-v2:16b` | [ओलामाCity name (optional, probably does not need a translation)](https://ollama.ai/library/deepseek-coder-v2) |
| `codellama:7b` | [ओलामाCity name (optional, probably does not need a translation)](https://ollama.ai/library/codellama) |
| `llama3.2:3b` बहुत तेजी से | स्वीकार्य [ओलामाCity name (optional, probably does not need a translation)](https://ollama.ai/library/llama3.2) |
अधिकतर प्रयोग के लिए **`qwen2.5-coder:7b`** सॉफ्ट स्पॉट करता है - सटीक SQL
## निष्पादन
### Real-विश्व मानदंड
एक मानक डेव मशीन पर 100K पंक्ति CSV फ़ाइल पर परीक्षण
क्वेरी प्रकार
|------------|------|
साधारण गणना
SUM के साथ | GROUP BY
फ़िल्टर के साथ जटिल समूहन
| बहु - तालिका समूह के साथ HAVING
पर विश्लेषणात्मक क्वेरी के लिए उप--100ms | | K पंक्तियों | - | किसी भी आयात चरण के बिना |. | क्वेरि जटिलता पंक्ति गणना से अधिक महत्वपूर्ण है
### बड़े फ़ाइलों को पार्केट में बदलें
से अधिक फ़ाइलों के लिए [पार्केट प्रारूप](https://parquet.apache.org/) है 10-100x तेजी से
```csharp
using var cmd = connection.CreateCommand();
cmd.CommandText = $"COPY (SELECT * FROM '{csvPath}') TO '{parquetPath}' (FORMAT PARQUET)";
cmd.ExecuteNonQuery();
```
संकुचित पार्केट फ़ाइल भी बहुत छोटा है.
### सुरक्षा संबंधी विचार
निष्पादित करने के दौरान LLM
```csharp
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));
}
```
डक डीबी में ' मेमोरी मोड भी प्राकृतिक अलगाव प्रदान करता है. यह आपके उत्पादन डेटाबेस को प्रभावित नहीं कर सकता
## पूर्ण उदाहरण
यहाँ यह सब कैसे एक साथ आता है
```csharp
// 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?"));
```
## सारांश
बनाए रखने के लिए मानसिक मॉडल **LLMs कारण**
LLM को डेटा फ़ीड नहीं करें।
क्रियान्वयन
1. **डक डीबी** सीएसवी सीधी से प्रश्न करता है - कोई आयात नहीं करता है
2. **योजना + नमूने** LLM को बिना डेटा के पर्याप्त संदर्भ दें
3. **कठोर प्रवर्धन नियम** बल निर्धारणात्मक SQL, रचनात्मक गद्य नहीं
4. **स्पष्टीकरण के माध्यम से वैधता** निष्पादन से पहले त्रुटि पकड़ता है
5. **त्रुटि प्रतिक्रिया के साथ पुनः प्रयास करें** कभी-कभी वाक्य संरचना स्लिप को संभालता है
परिणाम million पर विश्लेषणात्मक क्वेरी | - | पंक्ति फ़ाइल |, | पूरी तरह ऑफ़लाइन |
पूरा नमूना परियोजना इस पर उपलब्ध है [सबसे अधिक स्पष्ट](https://github.com/scottgal/mostlylucidweb) - में शामिल है `CsvQueryService`, `ConversationalCsvAnalyser`, और बोगस
## संसाधन
### डक डीबी
- [डकडीबी दस्तावेज़ीकरण](https://duckdb.org/docs/) - पूर्ण संदर्भ
- [डकडीबी सीएसवी आयात](https://duckdb.org/docs/data/csv/overview.html) विशेष विशेषताएँ
- [डकडीबी एसक्यूएल संदर्भ](https://duckdb.org/docs/sql/introduction) - अन्य डेटाबेसों से एसक्यूएल वाक्य संरचना अंतर
- [डकडीबी](https://github.com/Giorgi/DuckDB.NET) - CM SK1 बंधन
- [डकडीबी](https://www.nuget.org/packages/DuckDB.NET.Data.Full) - मूल द्विआधारी के साथ पूरा पैकेज
### Ollama & LLMs
- [ओलामाCity name (optional, probably does not need a translation)](https://ollama.ai/) - स्थानीय LLM रनटाइम
- [ओललामा मॉडल लाइब्रेरी](https://ollama.ai/library) उपलब्ध मॉडल
- [ओल्लामाशर्प](https://github.com/awaescher/OllamaSharp) क्लाइंट लाइब्रेरी
- [ओललामाशर्प नुगेट](https://www.nuget.org/packages/OllamaSharp/)
### डाटा बनाने का परीक्षण करें
- [बोगस जिटहब](https://github.com/bchavez/Bogus) - मिथ्या डेटा जनरेटर
- [बोगस API संदर्भ](https://github.com/bchavez/Bogus#bogus-api-support) - उपलब्ध डेटा प्रकार
### वैकल्पिक उल्लेखित
- [सीएसवीHelperComment](https://joshclose.github.io/CsvHelper/) - सीएसवी विश्लेषण लाइब्रेरी
- [माइक्रोसॉफ्ट](https://www.nuget.org/packages/Microsoft.Data.Analysis) के लिए - डेटाफ्रेम
- [पांडसAI](https://github.com/Sinaptik-AI/pandas-ai) - पाइथोन LLM
### संबंधित लेख
- [डेटासममारीजर: त्वरित स्थानीय डाटा प्रोफ़ाइलिंग](/blog/datasummarizer-how-it-works) - CLI के आधार पर डेटा प्रोफाइलिंग को शामिल करने वाला अनुषंगी अनुच्छेद