एक और MySQL DBA: AI

AI लेबलों वाले संदेश दिखाए जा रहे हैं. सभी संदेश दिखाएं

शनिवार, 21 फ़रवरी 2026

MySQL + Neo4j AI वर्कलोड्स के लिए: क्यों रिलेशनल डेटाबेस अभी भी महत्वपूर्ण हैं

This article was originally published in English at AnotherMySQLDBA.

तो मैंने सोचा कि अब समय आ गया है कि मैं दस्तावेजीकृत करूं कि कैसे पहले से ज्ञात डेटाबेस का उपयोग करके AI एजेंट्स के लिए पर्सिस्टेंट मेमोरी बनाई जाए। वेक्टर डेटाबेस नहीं - MySQL और Neo4j।

यह सैद्धांतिक नहीं है। मैं इस आर्किटेक्चर का रोजाना उपयोग करता हूं, कई प्रोजेक्ट्स में AI एजेंट मेमोरी को हैंडल करने के लिए। यह रहा वास्तव में काम करने वाला स्कीमा और क्वेरी पैटर्न।

द आर्किटेक्चर

AI एजेंट्स को दो प्रकार की मेमोरी की आवश्यकता होती है:

संरचित मेमोरी - क्या हुआ, कब, क्यों (MySQL)
पैटर्न मेमोरी - क्या किससे जुड़ा है (Neo4j)

वेक्टर डेटाबेस समानता खोज के लिए होते हैं। वे वर्कफ्लो स्टेट या निर्णय इतिहास को ट्रैक करने के लिए नहीं हैं। इसके लिए आपको ACID ट्रांजेक्शन्स और उचित रिलेशनशिप्स की आवश्यकता होती है।

MySQL स्कीमा

यह रहा AI एजेंट पर्सिस्टेंट मेमोरी के लिए वास्तविक स्कीमा:

-- Architecture decisions the AI made
CREATE TABLE architecture_decisions (
    id INT AUTO_INCREMENT PRIMARY KEY,
    project_id INT NOT NULL,
    title VARCHAR(255) NOT NULL,
    decision TEXT NOT NULL,
    rationale TEXT,
    alternatives_considered TEXT,
    status ENUM('accepted', 'rejected', 'pending') DEFAULT 'accepted',
    decided_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    tags JSON,
    INDEX idx_project_date (project_id, decided_at),
    INDEX idx_status (status)
) ENGINE=InnoDB;

-- Code patterns the AI learned
CREATE TABLE code_patterns (
    id INT AUTO_INCREMENT PRIMARY KEY,
    project_id INT NOT NULL,
    category VARCHAR(50) NOT NULL,
    name VARCHAR(255) NOT NULL,
    description TEXT,
    code_example TEXT,
    language VARCHAR(50),
    confidence_score FLOAT DEFAULT 0.5,
    usage_count INT DEFAULT 0,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    updated_at DATETIME ON UPDATE CURRENT_TIMESTAMP,
    INDEX idx_project_category (project_id, category),
    INDEX idx_confidence (confidence_score)
) ENGINE=InnoDB;

-- Work session tracking
CREATE TABLE work_sessions (
    id INT AUTO_INCREMENT PRIMARY KEY,
    session_id VARCHAR(255) UNIQUE NOT NULL,
    project_id INT NOT NULL,
    started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    ended_at DATETIME,
    summary TEXT,
    context JSON,
    INDEX idx_project_session (project_id, started_at)
) ENGINE=InnoDB;

-- Pitfalls to avoid (learned from mistakes)
CREATE TABLE pitfalls (
    id INT AUTO_INCREMENT PRIMARY KEY,
    project_id INT NOT NULL,
    category VARCHAR(50),
    title VARCHAR(255) NOT NULL,
    description TEXT,
    how_to_avoid TEXT,
    severity ENUM('critical', 'high', 'medium', 'low'),
    encountered_count INT DEFAULT 1,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    INDEX idx_project_severity (project_id, severity)
) ENGINE=InnoDB;

फॉरेन कीज। चेक कंस्ट्रेंट्स। उचित इंडेक्सिंग। यही रिलेशनल डेटाबेस की ताकत है।

क्वेरी पैटर्न्स

यह रहा AI एजेंट मेमोरी के लिए इसे वास्तव में कैसे क्वेरी करें:

-- Get recent decisions for context
SELECT title, decision, rationale, decided_at
FROM architecture_decisions
WHERE project_id = ?
  AND decided_at > DATE_SUB(NOW(), INTERVAL 30 DAY)
ORDER BY decided_at DESC
LIMIT 10;

-- Find high-confidence patterns
SELECT category, name, description, code_example
FROM code_patterns
WHERE project_id = ?
  AND confidence_score >= 0.80
ORDER BY usage_count DESC, confidence_score DESC
LIMIT 20;

-- Check for known pitfalls before implementing
SELECT title, description, how_to_avoid
FROM pitfalls
WHERE project_id = ?
  AND category = ?
  AND severity IN ('critical', 'high')
ORDER BY encountered_count DESC;

-- Track session context across interactions
SELECT context
FROM work_sessions
WHERE session_id = ?
ORDER BY started_at DESC
LIMIT 1;

ये सीधे-सादे SQL क्वेरीज़ हैं। EXPLAIN सटीक रूप से अपेक्षित इंडेक्स उपयोग दिखाता है। कोई सरप्राइज नहीं।

Neo4j लेयर

MySQL संरचित डेटा को हैंडल करता है। Neo4j रिलेशनशिप्स को हैंडल करता है:

// Create nodes for decisions
CREATE (d:Decision {
  id: 'dec_123',
  title: 'Use FastAPI',
  project_id: 1,
  embedding: [0.23, -0.45, ...]  // Vector for similarity
})

// Create relationships
CREATE (d1:Decision {id: 'dec_123', title: 'Use FastAPI'})
CREATE (d2:Decision {id: 'dec_45', title: 'Used Flask before'})
CREATE (d1)-[:SIMILAR_TO {score: 0.85}]->(d2)
CREATE (d1)-[:CONTRADICTS]->(d3:Decision {title: 'Avoid frameworks'})

// Query: Find similar past decisions
MATCH (current:Decision {id: $decision_id})
MATCH (current)-[r:SIMILAR_TO]-(similar:Decision)
WHERE r.score > 0.80
RETURN similar.title, r.score
ORDER BY r.score DESC

// Query: What outcomes followed this pattern?
MATCH (d:Decision)-[:LEADS_TO]->(o:Outcome)
WHERE d.title CONTAINS 'Redis'
RETURN d.title, o.type, o.success_rate

वे एक साथ कैसे काम करते हैं

फ्लो कुछ इस तरह दिखता है:

AI एजेंट कंटेंट जेनरेट करता है या निर्णय लेता है
MySQL में संरचित डेटा स्टोर करें (क्या, कब, क्यों, पूरा संदर्भ)
एम्बेडिंग जेनरेट करें, Neo4j में समान आइटम्स के साथ रिलेशनशिप्स के साथ स्टोर करें
अगली सेशन: Neo4j प्रासंगिक समान निर्णय ढूंढता है
MySQL उन निर्णयों का पूरा विवरण प्रदान करता है

MySQL सत्य का स्रोत है। Neo4j पैटर्न फाइंडर है।

क्यों सिर्फ वेक्टर डेटाबेस नहीं?

मैंने टीम्स को सिर्फ Pinecone या Weaviate से AI एजेंट मेमोरी बनाने की कोशिश करते देखा है। यह अच्छा काम नहीं करता क्योंकि:

वेक्टर DBs अच्छे हैं:

क्वेरी से समान दस्तावेज ढूंढने के लिए
सीमांटिक सर्च (RAG)
"इस तरह की चीजें"

वेक्टर DBs बुरे हैं:

"15 मार्च को हमने क्या निर्णय लिया?"
"मुझे वे निर्णय दिखाएं जो आउटेज का कारण बने"
"इस वर्कफ्लो की वर्तमान स्थिति क्या है?"
"किन पैटर्न्स का कॉन्फिडेंस > 0.8 AND usage_count > 10 है?"

ये क्वेरीज़ को संरचित फिल्टरिंग, जॉइन्स, और ट्रांजेक्शन्स की आवश्यकता होती है। यह रिलेशनल डेटाबेस का क्षेत्र है।

MCP और भविष्य

मॉडल कॉन्टेक्स्ट प्रोटोकॉल (MCP) AI सिस्टम्स द्वारा कॉन्टेक्स्ट को हैंडल करने के तरीके को स्टैंडर्डाइज कर रहा है। शुरुआती MCP इम्प्लीमेंटेशन्स वो खोज रही हैं जो हम पहले से जानते थे: आपको संरचित स्टोरेज और ग्राफ रिलेशनशिप्स दोनों की आवश्यकता है।

``````html

MySQL MCP "resources" और "tools" कैटलॉग को हैंडल करता है। Neo4j संदर्भ आइटम्स के बीच "relationships" को हैंडल करता है। Vector embeddings सिर्फ पहेली का एक टुकड़ा हैं।

Production Notes

वर्तमान सिस्टम जो इस आर्किटेक्चर को चला रहा है:

MySQL 8.0, 48 tables, ~2GB data
Neo4j Community, ~50k nodes, ~200k relationships
Query latency: MySQL <10ms, Neo4j <50ms
Backup: Standard mysqldump + neo4j-admin dump
Monitoring: Same Percona tools I've used for years

परिचालन जटिलता कम है क्योंकि ये परिपक्व databases हैं जिनके ऑपरेशनल पैटर्न अच्छी तरह समझे जाते हैं।

When to Use What

Use Case	Database
Workflow state, decisions, audit trail	MySQL/PostgreSQL
Pattern detection, similarity, relationships	Neo4j
Semantic document search (RAG)	Vector DB (optional)

State के लिए MySQL से शुरू करें। Pattern recognition की जरूरत हो तो Neo4j जोड़ें। केवल semantic document retrieval कर रहे हों तो ही vector DBs जोड़ें।

Summary

AI agents को persistent memory की जरूरत है। सिर्फ vector database में embeddings नहीं - structured, relational, temporal memory जिसमें pattern recognition हो।

MySQL structured state को हैंडल करता है। Neo4j graph relationships को हैंडल करता है। साथ में ये वही प्रदान करते हैं जो vector databases अकेले नहीं कर सकते।

AI workloads के लिए relational databases को न छोड़ें। हर काम के लिए सही tool इस्तेमाल करें, जो दोनों को साथ में इस्तेमाल करना है।

इस आर्किटेक्चर के AI agent perspective पर और जानने के लिए, 3k1o पर companion post देखें।

गुरुवार, 3 जुलाई 2025

MySQL विश्लेषण: AI-संचालित CLI टूल के साथ

स्रोत लेख (Source): https://anothermysqldba.blogspot.com/2025/07/mysql-analysis-with-ai-powered-cli-tool.html यह हिंदी अनुवाद है।

MySQL के साथ DBA के रूप में हम अक्सर Linux टर्मिनल विंडो पर काम करते हैं। हमें मुफ्त विकल्प भी पसंद हैं जब वे उपलब्ध हों। यह पोस्ट एक ऐसा दृष्टिकोण दिखाता है जो हमें अपनी टर्मिनल विंडो पर रहने और फिर भी AI-संचालित टूल का उपयोग करने की अनुमति देता है। आप अन्य प्रत्यक्ष AI प्रदाताओं का उपयोग करने के लिए अपडेट कर सकते हैं लेकिन मैंने इस उदाहरण को aimlapi.com का उपयोग करने के लिए सेट किया है क्योंकि यह सीमित उपयोग के लिए मुफ्त या अधिक परीक्षण के लिए बहुत कम लागत के साथ कई AI मॉडल आपके टर्मिनल पर लाता है।

नोट: मैं AIMLAPI का कोई भुगतान प्राप्त प्रवक्ता नहीं हूं या कुछ भी - यह केवल विचार को उजागर करने के लिए एक आसान उदाहरण है।

समस्या

आप सैकड़ों टेबल के साथ एक legacy डेटाबेस को देख रहे हैं, जिसमें से प्रत्येक में जटिल संबंध और वर्षों पहले किए गए संदिग्ध डिज़ाइन निर्णय हैं। सामान्य प्रक्रिया में शामिल है:

मैनुअल स्कीमा निरीक्षण
क्रॉस-रेफरेंसिंग दस्तावेज (यदि यह मौजूद है)
कई EXPLAIN क्वेरी चलाना
सर्वोत्तम अभ्यास गाइड से सलाह लेना
सहयोगियों से दूसरी राय मांगना

इसमें समय लगता है और आप अक्सर चीजों को मिस कर देते हैं।

CLI-आधारित दृष्टिकोण

हम AI का लाभ सीधे अपनी CLI से उठा सकते हैं और कई काम कर सकते हैं। MySQL विश्लेषण में मदद करना केवल एक उदाहरण है कि यह दृष्टिकोण हमारे दैनिक डेटाबेस कार्यों के साथ कैसे काम कर सकता है। MySQL की मूल क्षमताओं को AI मॉडल के साथ जोड़कर, सभी एक साधारण कमांड-लाइन इंटरफेस के माध्यम से पहुंच योग्य, हम अपनी टर्मिनल छोड़े बिना अंतर्दृष्टि प्राप्त कर सकते हैं। AIMLAPI सीमित उपयोग के साथ 100+ AI मॉडल तक मुफ्त पहुंच प्रदान करता है, जिससे यह दृष्टिकोण सुलभ हो जाता है। भारी परीक्षण के लिए, लागत बहुत उचित रहती है।

टूल: AIMLAPI CLI

तो यहां एक bash स्क्रिप्ट है जो एक एकल इंटरफेस के माध्यम से 100+ AI मॉडल तक पहुंच प्रदान करती है:

#!/bin/bash
# 100+ AI मॉडल तक पहुंच के साथ AIMLAPI CLI टूल
# फ़ाइल: ~/.local/bin/aiml

# कॉन्फ़िगरेशन
DEFAULT_MODEL=${AIMLAPI_DEFAULT_MODEL:-"gpt-4o"}
MAX_TOKENS=${AIMLAPI_MAX_TOKENS:-2000}
TEMPERATURE=${AIMLAPI_TEMPERATURE:-0.7}
BASE_URL="https://api.aimlapi.com"
ENDPOINT="v1/chat/completions"

# आउटपुट के लिए रंग कोड
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
PURPLE='\033[0;35m'
CYAN='\033[0;36m'
NC='\033[0m' # कोई रंग नहीं

# रंगीन आउटपुट प्रिंट करने के लिए फ़ंक्शन
print_info() { echo -e "${BLUE}[INFO]${NC} $1"; }
print_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; }
print_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; }
print_error() { echo -e "${RED}[ERROR]${NC} $1"; }
print_model() { echo -e "${PURPLE}[MODEL]${NC} $1"; }

# लोकप्रिय मॉडल शॉर्टकट
declare -A MODEL_SHORTCUTS=(
    # OpenAI मॉडल
    ["gpt4"]="gpt-4o"
    ["gpt4o"]="gpt-4o"
    ["gpt4mini"]="gpt-4o-mini"
    ["o1"]="o1-preview"
    ["o3"]="openai/o3-2025-04-16"
    
    # Claude मॉडल  
    ["claude"]="claude-3-5-sonnet-20241022"
    ["claude4"]="anthropic/claude-sonnet-4"
    ["opus"]="claude-3-opus-20240229"
    ["haiku"]="claude-3-5-haiku-20241022"
    ["sonnet"]="claude-3-5-sonnet-20241022"
    
    # DeepSeek मॉडल
    ["deepseek"]="deepseek-chat"
    ["deepseek-r1"]="deepseek/deepseek-r1"
    ["reasoner"]="deepseek-reasoner"
    
    # Google मॉडल
    ["gemini"]="gemini-2.0-flash"
    ["gemini2"]="gemini-2.0-flash"
    ["gemini15"]="gemini-1.5-pro"
    
    # Meta Llama मॉडल
    ["llama"]="meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo"
    ["llama405b"]="meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo"
    
    # Qwen मॉडल
    ["qwen"]="qwen-max"
    ["qwq"]="Qwen/QwQ-32B"
    
    # Grok मॉडल
    ["grok"]="x-ai/grok-beta"
    ["grok3"]="x-ai/grok-3-beta"
    
    # विशेषीकृत मॉडल
    ["coder"]="Qwen/Qwen2.5-Coder-32B-Instruct"
)

# मॉडल शॉर्टकट को हल करने के लिए फ़ंक्शन
resolve_model() {
    local model="$1"
    if [[ -n "${MODEL_SHORTCUTS[$model]}" ]]; then
        echo "${MODEL_SHORTCUTS[$model]}"
    else
        echo "$model"
    fi
}

# उचित escaping के लिए jq का उपयोग करके JSON payload बनाने के लिए फ़ंक्शन
create_json_payload() {
    local model="$1"
    local prompt="$2"
    local system_prompt="$3"
    
    local temp_file=$(mktemp)
    echo "$prompt" > "$temp_file"
    
    if [ -n "$system_prompt" ]; then
        jq -n --arg model "$model" \
              --rawfile prompt "$temp_file" \
              --arg system "$system_prompt" \
              --argjson max_tokens "$MAX_TOKENS" \
              --argjson temperature "$TEMPERATURE" \
              '{
                model: $model,
                messages: [{role: "system", content: $system}, {role: "user", content: $prompt}],
                max_tokens: $max_tokens,
                temperature: $temperature
              }'
    else
        jq -n --arg model "$model" \
              --rawfile prompt "$temp_file" \
              --argjson max_tokens "$MAX_TOKENS" \
              --argjson temperature "$TEMPERATURE" \
              '{
                model: $model,
                messages: [{role: "user", content: $prompt}],
                max_tokens: $max_tokens,
                temperature: $temperature
              }'
    fi
    
    rm -f "$temp_file"
}

# AIMLAPI को कॉल करने के लिए फ़ंक्शन
call_aimlapi() {
    local prompt="$1"
    local model="$2"
    local system_prompt="$3"
    
    if [ -z "$AIMLAPI_API_KEY" ]; then
        print_error "AIMLAPI_API_KEY सेट नहीं है"
        return 1
    fi
    
    model=$(resolve_model "$model")
    
    local json_file=$(mktemp)
    create_json_payload "$model" "$prompt" "$system_prompt" > "$json_file"
    
    local response_file=$(mktemp)
    local http_code=$(curl -s -w "%{http_code}" -X POST "${BASE_URL}/${ENDPOINT}" \
        -H "Content-Type: application/json" \
        -H "Authorization: Bearer $AIMLAPI_API_KEY" \
        --data-binary @"$json_file" \
        -o "$response_file")
    
    if [ "$http_code" -ne 200 ] && [ "$http_code" -ne 201 ]; then
        print_error "HTTP त्रुटि $http_code"
        cat "$response_file" >&2
        rm -f "$json_file" "$response_file"
        return 1
    fi
    
    local content=$(jq -r '.choices[0].message.content // empty' "$response_file" 2>/dev/null)
    
    if [ -z "$content" ]; then
        content=$(jq -r '.choices[0].text // .message.content // .content // empty' "$response_file" 2>/dev/null)
    fi
    
    if [ -z "$content" ]; then
        local error_msg=$(jq -r '.error.message // .error // empty' "$response_file" 2>/dev/null)
        if [ -n "$error_msg" ]; then
            echo "API त्रुटि: $error_msg"
        else
            echo "त्रुटि: API से प्रतिक्रिया पार्स करने में असमर्थ"
        fi
    else
        echo "$content"
    fi
    
    rm -f "$json_file" "$response_file"
}

# तर्क पार्सिंग के साथ मुख्य फ़ंक्शन
main() {
    local model="$DEFAULT_MODEL"
    local system_prompt=""
    local prompt=""
    local piped_input=""
    
    if [ -p /dev/stdin ]; then
        piped_input=$(cat)
    fi
    
    # तर्कों को पार्स करें
    while [[ $# -gt 0 ]]; do
        case $1 in
            -m|--model)
                model="$2"
                shift 2
                ;;
            -s|--system)
                system_prompt="$2"
                shift 2
                ;;
            *)
                prompt="$*"
                break
                ;;
        esac
    done
    
    # इनपुट को हैंडल करें
    if [ -n "$piped_input" ] && [ -n "$prompt" ]; then
        prompt="$prompt

यहां विश्लेषण के लिए डेटा है:
$piped_input"
    elif [ -n "$piped_input" ]; then
        prompt="कृपया इस डेटा का विश्लेषण करें:

$piped_input"
    elif [ -z "$prompt" ]; then
        echo "उपयोग: aiml [विकल्प] \"प्रॉम्प्ट\""
        echo "       कमांड | aiml [विकल्प]"
        exit 1
    fi
    
    local resolved_model=$(resolve_model "$model")
    print_info "$resolved_model से पूछताछ कर रहे हैं..."
    
    local response=$(call_aimlapi "$prompt" "$model" "$system_prompt")
    
    echo ""
    print_model "$resolved_model से प्रतिक्रिया:"
    echo "----------------------------------------"
    echo "$response" 
    echo "----------------------------------------"
}

# निर्भरताओं की जांच करें
check_dependencies() {
    command -v curl >/dev/null 2>&1 || { print_error "curl आवश्यक है लेकिन इंस्टॉल नहीं है।"; exit 1; }
    command -v jq >/dev/null 2>&1 || { print_error "jq आवश्यक है लेकिन इंस्टॉल नहीं है।"; exit 1; }
}

check_dependencies
main "$@"

यह स्क्रिप्ट claude4, gpt4, grok3, आदि जैसे सरल शॉर्टकट के माध्यम से विभिन्न AI मॉडल तक पहुंच प्रदान करती है। AIMLAPI इन सभी मॉडल के लिए सीमित उपयोग के साथ मुफ्त पहुंच प्रदान करता है, अतिरिक्त परीक्षण के लिए उचित लागत के साथ। उन DBA के लिए अच्छा है जो बजट तोड़े बिना प्रयोग करना चाहते हैं।

स्क्रिप्ट सुविधाएं

स्क्रिप्ट में व्यापक सहायता शामिल है। यहां aiml --help दिखाता है:

AIMLAPI CLI टूल - 100+ AI मॉडल तक पहुंच
==============================================
उपयोग: aiml [विकल्प] "प्रॉम्प्ट"
       कमांड | aiml [विकल्प]

मुख्य विकल्प:
  -m, --model MODEL         उपयोग करने के लिए मॉडल (डिफ़ॉल्ट: gpt-4o)
  -t, --tokens NUMBER       अधिकतम टोकन (डिफ़ॉल्ट: 2000)
  -T, --temperature FLOAT   टेम्परेचर 0.0-2.0 (डिफ़ॉल्ट: 0.7)
  -s, --system PROMPT       मॉडल व्यवहार के लिए सिस्टम प्रॉम्प्ट

इनपुट/आउटपुट विकल्प:
  -f, --file FILE           फ़ाइल से प्रॉम्प्ट पढ़ें
  -o, --output FILE         प्रतिक्रिया को फ़ाइल में सेव करें
  -r, --raw                 कच्चा आउटपुट (कोई फ़ॉर्मेटिंग/रंग नहीं)

जानकारी विकल्प:
  -l, --list               लोकप्रिय मॉडल शॉर्टकट सूची दिखाएं
  --get-models             API से सभी उपलब्ध मॉडल प्राप्त करें
  -c, --config             वर्तमान कॉन्फ़िगरेशन दिखाएं
  -v, --verbose            विस्तृत आउटपुट सक्षम करें
  -d, --debug              डिबग जानकारी दिखाएं
  -h, --help               यह सहायता दिखाएं

बुनियादी उदाहरण:
  aiml "क्वांटम कंप्यूटिंग समझाएं"
  aiml -m claude "इस कोड की समीक्षा करें"
  aiml -m deepseek-r1 "इस गणित समस्या को चरणबद्ध तरीके से हल करें"
  aiml -m grok3 "नवीनतम AI विकास क्या हैं?"
  aiml -m coder "इस Python फ़ंक्शन को अनुकूलित करें"

पाइप उदाहरण:
  ps aux | aiml "इन प्रक्रियाओं का विश्लेषण करें"
  netstat -tuln | aiml "इन नेटवर्क कनेक्शन को समझाएं"
  cat error.log | aiml -m claude "इन त्रुटियों का निदान करें"
  git diff | aiml -m coder "इन कोड परिवर्तनों की समीक्षा करें"
  df -h | aiml "डिस्क उपयोग का विश्लेषण करें और सफाई सुझाएं"

फ़ाइल संचालन:
  aiml -f prompt.txt -o response.txt
  aiml -f large_dataset.csv -m llama405b "इस डेटा का विश्लेषण करें"
  cat script.py | aiml -m coder -o review.md "कोड समीक्षा"

मॉडल श्रेणियां और शॉर्टकट:
  OpenAI:     gpt4, gpt4mini, o1, o3
  Claude:     claude, opus, haiku, sonnet, claude4
  DeepSeek:   deepseek, deepseek-r1, reasoner
  Google:     gemini, gemini2, gemma
  Meta:       llama, llama3, llama4, llama405b
  Qwen:       qwen, qwen2, qwq
  Grok:       grok, grok3, grok3mini
  Coding:     coder, codestral

उन्नत उपयोग:
  aiml -m claude -s "आप एक सुरक्षा विशेषज्ञ हैं" "इस कोड का ऑडिट करें"
  aiml -m deepseek-r1 -t 3000 "जटिल तर्क कार्य"
  aiml -v -m grok3 "विस्तृत लॉगिंग के साथ विस्तृत क्वेरी"
  aiml -d "API समस्याओं को ट्रबलशूट करने के लिए डिबग मोड"

मॉडल खोज:
  aiml -l                   # लोकप्रिय शॉर्टकट दिखाएं
  aiml --get-models         # API से सभी उपलब्ध मॉडल प्राप्त करें
  aiml --config             # वर्तमान कॉन्फ़िगरेशन दिखाएं

पर्यावरण चर:
  AIMLAPI_API_KEY          - आपकी AIMLAPI कुंजी (आवश्यक)
  AIMLAPI_DEFAULT_MODEL    - डिफ़ॉल्ट मॉडल (वैकल्पिक)
  AIMLAPI_MAX_TOKENS       - डिफ़ॉल्ट अधिकतम टोकन (वैकल्पिक)
  AIMLAPI_TEMPERATURE      - डिफ़ॉल्ट टेम्परेचर (वैकल्पिक)

प्रो टिप्स:
  • प्रोग्रामिंग कार्यों और कोड समीक्षा के लिए coder का उपयोग करें
  • जटिल तर्क और गणित समस्याओं के लिए deepseek-r1 का उपयोग करें
  • विस्तृत विश्लेषण और लंबे-रूप सामग्री के लिए claude4 का उपयोग करें
  • वर्तमान घटनाओं और रीयल-टाइम जानकारी के लिए grok3 का उपयोग करें
  • API लागत बचाने के लिए त्वरित प्रश्नों के लिए gpt4mini का उपयोग करें
  • कमांड आउटपुट को सीधे पाइप करें: command | aiml "इसका विश्लेषण करें"
  • कौन सा मॉडल उपयोग हो रहा है देखने के लिए -v का उपयोग करें
  • सभी 100+ उपलब्ध मॉडल देखने के लिए --get-models का उपयोग करें

एक सरल इंटरफेस के माध्यम से 100+ AI मॉडल तक पहुंच!

उदाहरण: City टेबल

यहां बताया गया है कि यह वास्तविक MySQL टेबल विश्लेषण के साथ कैसे काम करता है। मैं क्लासिक World डेटाबेस (https://dev.mysql.com/doc/index-other.html Example Databases से) से एक City टेबल का विश्लेषण तीन अलग-अलग AI मॉडल का उपयोग करके करूंगा।

कमांड

mysql --login-path=klarson world -e "show create table City\G" | \
aiml --model claude4 "MySQL विशेषज्ञ दृष्टिकोण का उपयोग करके इस टेबल का विश्लेषण करें"

यह कमांड:

MySQL से टेबल संरचना निकालता है
इसे हमारे AI टूल में पाइप करता है
Claude Sonnet 4 से विश्लेषण प्राप्त करता है

परिणाम

Claude Sonnet 4 विश्लेषण

Claude 4 ने एक अच्छी तरह से संगठित विश्लेषण प्रदान किया:

ताकतें:

InnoDB दक्षता के लिए उचित AUTO_INCREMENT प्राथमिक कुंजी
referential integrity बनाए रखने वाली Foreign key बाधाएं
सामान्य क्वेरीज़ के लिए उपयुक्त इंडेक्सिंग रणनीति

मिली समस्याएं:

भंडारण अक्षमता: परिवर्तनीय-लंबाई शहर के नामों के लिए CHAR(35) का उपयोग स्थान बर्बाद करता है
चरित्र सेट सीमा: अंतर्राष्ट्रीय शहर के नामों के लिए latin1 charset अपर्याप्त
उप-इष्टतम इंडेक्सिंग: name_key इंडेक्स केवल पहले 5 वर्णों को कवर करता है

सुझाए गए सुधार:

-- Claude की सुझाई गई अनुकूलित संरचना
CREATE TABLE `City` (
  `ID` int NOT NULL AUTO_INCREMENT,
  `Name` VARCHAR(35) NOT NULL,
  `CountryCode` CHAR(3) NOT NULL,
  `District` VARCHAR(20) NOT NULL,
  `Population` int UNSIGNED NOT NULL DEFAULT '0',
  PRIMARY KEY (`ID`),
  KEY `CountryCode` (`CountryCode`),
  KEY `name_idx` (`Name`),
  KEY `country_name_idx` (`CountryCode`, `Name`),
  KEY `population_idx` (`Population`),
  CONSTRAINT `city_ibfk_1` FOREIGN KEY (`CountryCode`) 
    REFERENCES `Country` (`Code`) ON DELETE RESTRICT ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=4080 
  DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

Grok 3 Beta विश्लेषण (व्यापक समीक्षक)

mysql --login-path=klarson world -e "show create table City\G" | \
aiml --model grok3 "MySQL विशेषज्ञ दृष्टिकोण का उपयोग करके इस टेबल का विश्लेषण करें"

Grok 3 ने एक संपूर्ण, विस्तृत विश्लेषण प्रदान किया जिसमें शामिल था:

तकनीकी गहरी जांच:

प्रदर्शन प्रभाव विश्लेषण: आंशिक इंडेक्स सीमा का विस्तार से मूल्यांकन
भंडारण इंजन लाभ: लेनदेन अखंडता के लिए InnoDB विकल्प की पुष्टि
डेटा प्रकार अनुकूलन: उदाहरणों के साथ विस्तृत स्थान-बचत सिफारिशें

उन्नत विचार:

शहर के नाम की खोज के लिए पूर्ण-पाठ इंडेक्सिंग सिफारिशें
विशिष्ट कमांड के साथ चरित्र सेट माइग्रेशन प्रक्रियाएं
बड़े डेटासेट के लिए विभाजन रणनीतियां

कार्यान्वयन दिशानिर्देश:

-- Grok का चरित्र सेट माइग्रेशन सुझाव
ALTER TABLE City CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

-- पूर्ण-पाठ इंडेक्स सिफारिश
ALTER TABLE City ADD FULLTEXT INDEX name_fulltext (Name);

GPT-4o विश्लेषण (व्यावहारिक सलाहकार)

mysql --login-path=klarson world -e "show create table City\G" | \
aiml --model gpt4 "MySQL विशेषज्ञ दृष्टिकोण का उपयोग करके इस टेबल का विश्लेषण करें"

GPT-4o ने व्यावहारिक, तुरंत क्रियान्वित करने योग्य सुधारों पर ध्यान केंद्रित किया:

व्यावहारिक मूल्यांकन:

AUTO_INCREMENT प्राथमिक कुंजी डिज़ाइन की मान्यता
डेटा अखंडता के लिए foreign key बाधा लाभों की पुष्टि
वैश्विक अनुप्रयोगों के लिए चरित्र सेट सीमाओं की पहचान

तैयार-कार्यान्वयन सुझाव:

तत्काल अनुकूलन के लिए विशिष्ट ALTER TABLE कमांड
क्वेरी पैटर्न विश्लेषण सिफारिशें
इंडेक्स प्रभावशीलता मूल्यांकन मानदंड

बहु-मॉडल विश्लेषण की शक्ति

इस दृष्टिकोण को मूल्यवान बनाता है तीन अलग दृष्टिकोण प्राप्त करना:

Claude 4: ठोस कोड समाधानों के साथ विस्तृत, संरचित विश्लेषण प्रदान करता है
Grok 3: उन्नत अनुकूलन रणनीतियों के साथ व्यापक कवरेज प्रदान करता है
GPT-4o: व्यावहारिक, तुरंत क्रियान्वित करने योग्य सिफारिशें देता है

प्रत्येक मॉडल अनोखी ताकतें लाता है:

विभिन्न फोकल पॉइंट: भंडारण अनुकूलन बनाम प्रदर्शन बनाम रखरखाव
अलग गहराई स्तर: त्वरित जीत से लेकर वास्तुशिल्प सुधार तक
विविध विश्लेषण शैलियां: संरचित बनाम व्यापक बनाम व्यावहारिक

वर्कफ़्लो का कार्यान्वयन

सेटअप निर्देश

1. निर्भरताएं इंस्टॉल करें:

# आवश्यक टूल इंस्टॉल करें
sudo apt install curl jq mysql-client

# स्क्रिप्ट डायरेक्टरी बनाएं
mkdir -p ~/.local/bin

# स्क्रिप्ट को निष्पादन योग्य बनाएं
chmod +x ~/.local/bin/aiml

2. API पहुंच कॉन्फ़िगर करें:

# https://aimlapi.com से अपनी मुफ्त AIMLAPI कुंजी प्राप्त करें (सीमित उपयोग के साथ मुफ्त टियर)
export AIMLAPI_API_KEY="your-free-api-key-here"
echo 'export AIMLAPI_API_KEY="your-free-api-key-here"' >> ~/.bashrc

3. सेटअप का परीक्षण करें:

# कॉन्फ़िगरेशन सत्यापित करें
aiml --config

# बुनियादी कार्यक्षमता का परीक्षण करें
echo "SELECT VERSION();" | aiml "इस SQL को समझाएं"

व्यावहारिक उपयोग पैटर्न

त्वरित टेबल विश्लेषण

# एक विशिष्ट टेबल का विश्लेषण करें
mysql -e "SHOW CREATE TABLE users\G" mydb | \
aiml -m claude4 "इस MySQL टेबल संरचना का विश्लेषण करें"

विभिन्न मॉडल दृष्टिकोणों की तुलना करें

# एक ही टेबल पर कई दृष्टिकोण प्राप्त करें
TABLE_DDL=$(mysql -e "SHOW CREATE TABLE orders\G" ecommerce)

echo "$TABLE_DDL" | aiml -m claude4 "MySQL टेबल विश्लेषण"
echo "$TABLE_DDL" | aiml -m grok3 "प्रदर्शन अनुकूलन समीक्षा" 
echo "$TABLE_DDL" | aiml -m gpt4 "व्यावहारिक सुधार सुझाव"

कई टेबल का विश्लेषण करें

# डेटाबेस में सभी टेबल का त्वरित विश्लेषण
mysql -e "SHOW TABLES;" mydb | \
while read table; do
  echo "=== $table का विश्लेषण कर रहे हैं ==="
  mysql -e "SHOW CREATE TABLE $table\G" mydb | \
  aiml -m gpt4mini "इस टेबल का त्वरित मूल्यांकन"
done

इंडेक्स विश्लेषण

# इंडेक्स उपयोग और अनुकूलन की समीक्षा करें
mysql -e "SHOW INDEX FROM tablename;" database | \
aiml -m deepseek "इस MySQL टेबल के लिए इंडेक्स अनुकूलन सुझाएं"

क्वेरी प्रदर्शन विश्लेषण

# धीमी क्वेरीज़ का विश्लेषण करें
mysql -e "SHOW PROCESSLIST;" | \
aiml -m grok3 "इन MySQL प्रक्रियाओं में संभावित प्रदर्शन समस्याओं की पहचान करें"

AIMLAPI DBAs के लिए इसे क्यों संभव बनाता है

उचित लागत के साथ मुफ्त पहुंच: AIMLAPI 100+ AI मॉडल के लिए सीमित उपयोग के साथ मुफ्त पहुंच प्रदान करता है, अतिरिक्त परीक्षण के लिए बहुत उचित मूल्य निर्धारण के साथ। यह उन DBAs के लिए एकदम सही है जो महंगी सब्सक्रिप्शन के लिए प्रतिबद्ध हुए बिना प्रयोग करना चाहते हैं।

मॉडल विविधता: विभिन्न प्रदाताओं (OpenAI, Anthropic, Google, Meta, आदि) के मॉडल तक पहुंच का मतलब है कि आपको विविध दृष्टिकोण और विशेषज्ञता क्षेत्र मिलते हैं।

कोई विक्रेता लॉक-इन नहीं: आप लंबी अवधि की प्रतिबद्धताओं के बिना अपनी विशिष्ट आवश्यकताओं के लिए सबसे अच्छा काम करने वाले विभिन्न मॉडल के साथ प्रयोग कर सकते हैं।

टर्मिनल-नेटिव: आपके आरामदायक Linux वातावरण में रहता है जहां आप पहले से ही अपना MySQL काम कर रहे हैं।

मॉडल चयन गाइड

विभिन्न मॉडल MySQL विश्लेषण के विभिन्न पहलुओं में उत्कृष्ट हैं:

# विस्तृत संरचनात्मक विश्लेषण के लिए
aiml -m claude4 "व्यापक टेबल संरचना समीक्षा"

# प्रदर्शन-केंद्रित विश्लेषण के लिए  
aiml -m grok3 "प्रदर्शन अनुकूलन सिफारिशें"

# त्वरित, व्यावहारिक सुझावों के लिए
aiml -m gpt4 "तत्काल क्रियान्वित करने योग्य सुधार"

# ट्रेड-ऑफ के बारे में जटिल तर्क के लिए
aiml -m deepseek-r1 "जटिल अनुकूलन ट्रेड-ऑफ विश्लेषण"

# लागत-प्रभावी त्वरित जांच के लिए
aiml -m gpt4mini "संक्षिप्त टेबल मूल्यांकन"

MySQL से परे: अन्य CLI उदाहरण

चूंकि हम किसी भी कमांड आउटपुट को AI टूल में पाइप कर सकते हैं, यहां कुछ अन्य उपयोगी उदाहरण हैं:

सिस्टम प्रशासन

# सिस्टम प्रक्रियाओं का विश्लेषण करें
ps aux | aiml "कौन सी प्रक्रियाएं सबसे अधिक संसाधन उपयोग कर रही हैं?"

# डिस्क उपयोग की जांच करें
df -h | aiml "डिस्क उपयोग का विश्लेषण करें और सफाई सुझाएं"

# नेटवर्क कनेक्शन
netstat -tuln | aiml "इन नेटवर्क कनेक्शन को समझाएं"

# सिस्टम लॉग
tail -50 /var/log/syslog | aiml "इन लॉग में कोई चिंताजनक त्रुटियां हैं?"

फ़ाइल और डायरेक्टरी विश्लेषण

# बड़ी फ़ाइलें
find /var -size +100M | aiml "इन बड़ी फ़ाइलों को प्रकार के अनुसार व्यवस्थित करें"

# अनुमति समस्याएं
ls -la /etc/mysql/ | aiml "सुरक्षा के लिए इन फ़ाइल अनुमतियों की जांच करें"

# कॉन्फ़िगरेशन समीक्षा
cat /etc/mysql/my.cnf | aiml "इस MySQL कॉन्फ़िगरेशन की समीक्षा करें"

लॉग विश्लेषण

# Apache लॉग
tail -100 /var/log/apache2/error.log | aiml "इन वेब सर्वर त्रुटियों को सारांशित करें"

# प्रमाणीकरण लॉग
grep "Failed password" /var/log/auth.log | aiml "इन असफल लॉगिन प्रयासों का विश्लेषण करें"

मुद्दा यह है कि आप अपनी टर्मिनल छोड़े बिना त्वरित विश्लेषण प्राप्त करने के लिए लगभग कुछ भी पाइप कर सकते हैं।

कस्टम सिस्टम प्रॉम्प्ट

अपने विशिष्ट संदर्भ के लिए विश्लेषण को तैयार करें:

# ई-कॉमर्स फोकस
aiml -m claude4 -s "आप एक उच्च-ट्रैफिक ई-कॉमर्स साइट के लिए टेबल का विश्लेषण कर रहे हैं" \
"स्केलेबिलिटी के लिए इस टेबल की समीक्षा करें"

# सुरक्षा फोकस
aiml -m grok3 -s "आप एक सुरक्षा-केंद्रित डेटाबेस विश्लेषक हैं" \
"इस टेबल संरचना का सुरक्षा मूल्यांकन"

# Legacy सिस्टम फोकस
aiml -m gpt4 -s "आप एक legacy सिस्टम को आधुनिक MySQL में माइग्रेट करने में मदद कर रहे हैं" \
"इस टेबल के लिए आधुनिकीकरण सिफारिशें"

स्वचालित रिपोर्टिंग

# एक व्यापक डेटाबेस विश्लेषण रिपोर्ट तैयार करें
DB_NAME="production_db"
REPORT_FILE="analysis_$(date +%Y%m%d).md"

echo "# $DB_NAME के लिए डेटाबेस विश्लेषण रिपोर्ट" > "$REPORT_FILE"
echo "$(date) को तैयार की गई" >> "$REPORT_FILE"

for table in $(mysql -Ns -e "SHOW TABLES;" "$DB_NAME"); do
  echo "" >> "$REPORT_FILE"
  echo "## टेबल: $table" >> "$REPORT_FILE"
  
  mysql -e "SHOW CREATE TABLE $table\G" "$DB_NAME" | \
  aiml -m claude4 "इस MySQL टेबल का संक्षिप्त विश्लेषण प्रदान करें" >> "$REPORT_FILE"
done

प्रदर्शन अनुकूलन वर्कफ़्लो

# व्यापक प्रदर्शन विश्लेषण
mysql -e "SHOW CREATE TABLE heavy_table\G" db | \
aiml -m grok3 "प्रदर्शन बाधा विश्लेषण"

# इंडेक्स सुझावों के साथ फॉलो अप
mysql -e "SHOW INDEX FROM heavy_table;" db | \
aiml -m deepseek "इंडेक्स अनुकूलन रणनीति"

# कार्यान्वयन योजना प्राप्त करें
aiml -m gpt4 "इन अनुकूलन के लिए चरणबद्ध कार्यान्वयन योजना बनाएं"

इस दृष्टिकोण के वास्तविक लाभ

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

सर्वोत्तम परिणामों के लिए सुझाव

संरचना से शुरू करें: व्यापक विश्लेषण के लिए हमेशा SHOW CREATE TABLE से शुरू करें
विशिष्ट प्रॉम्प्ट का उपयोग करें: आपका अनुरोध जितना अधिक विशिष्ट होगा, विश्लेषण उतना ही बेहतर होगा
मॉडल की तुलना करें: विभिन्न मॉडल विभिन्न पहलुओं में उत्कृष्ट हैं - कई दृष्टिकोण का उपयोग करें
सुझावों को सत्यापित करें: हमेशा विकास वातावरण में पहले AI सिफारिशों का परीक्षण करें
दोहराएं: विशिष्ट सिफारिशों में गहराई से जाने के लिए फॉलो-अप प्रश्नों का उपयोग करें

आज ही शुरुआत करना

इस दृष्टिकोण की सुंदरता इसकी सरलता और लागत-प्रभावशीलता है। केवल कुछ कमांड के साथ, आप:

https://aimlapi.com से अपनी मुफ्त AIMLAPI कुंजी प्राप्त करें (मुफ्त टियर शामिल)
स्क्रिप्ट इंस्टॉल करें (5 मिनट)
तुरंत अपनी MySQL टेबल का विश्लेषण शुरू करें
विभिन्न मॉडल के साथ प्रयोग करके देखें कि आपकी आवश्यकताओं के लिए कौन से सबसे अच्छे काम करते हैं
नियमित विश्लेषण के लिए मुफ्त टियर का उपयोग करें, केवल भारी परीक्षण के लिए भुगतान करें

Windows उपयोगकर्ता (त्वरित विकल्प)

मैं Windows व्यक्ति नहीं हूं, लेकिन यदि आपको इसे Windows पर चलाने की आवश्यकता है, तो सबसे सरल दृष्टिकोण है:

WSL2 इंस्टॉल करें (Windows Subsystem for Linux)
Microsoft Store से Ubuntu इंस्टॉल करें
WSL2 के अंदर ऊपर के Linux सेटअप का पालन करें

यह आपको एक उचित Linux वातावरण देता है जहां स्क्रिप्ट बिल्कुल वैसे ही काम करेगी जैसे डिज़ाइन की गई है।

यह DBA विशेषज्ञता को बदलने के बारे में नहीं है - यह आपके टर्मिनल वातावरण में रहते हुए इसे बढ़ाने के बारे में है। AI तेज़ विश्लेषण प्रदान करता है और उन चीजों को पकड़ता है जिन्हें आप चूक सकते हैं, जबकि आप संदर्भ प्रदान करते हैं और अंतिम निर्णय लेते हैं।

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

MySQL की शक्तिशाली introspection क्षमताओं और AI विश्लेषण का संयोजन एक ऐसा वर्कफ़्लो बनाता है जो DBAs के लिए व्यावहारिक और लागत-प्रभावी दोनों है। अपने अगले डेटाबेस अनुकूलन प्रोजेक्ट पर इसे आज़माएं - आप इस बात से आश्चर्यचकित हो सकते हैं कि क्या अंतर्दृष्टि उभरती है, सभी आपके आरामदायक टर्मिनल वातावरण में रहते हुए।

Pages

शनिवार, 21 फ़रवरी 2026

MySQL + Neo4j AI वर्कलोड्स के लिए: क्यों रिलेशनल डेटाबेस अभी भी महत्वपूर्ण हैं

द आर्किटेक्चर

MySQL स्कीमा

क्वेरी पैटर्न्स

Neo4j लेयर

वे एक साथ कैसे काम करते हैं

क्यों सिर्फ वेक्टर डेटाबेस नहीं?

MCP और भविष्य

Production Notes

When to Use What

Summary

गुरुवार, 3 जुलाई 2025

MySQL विश्लेषण: AI-संचालित CLI टूल के साथ

MySQL विश्लेषण: AI-संचालित CLI टूल के साथ

समस्या

CLI-आधारित दृष्टिकोण

टूल: AIMLAPI CLI

स्क्रिप्ट सुविधाएं

उदाहरण: City टेबल

कमांड

परिणाम

Claude Sonnet 4 विश्लेषण

Grok 3 Beta विश्लेषण (व्यापक समीक्षक)

GPT-4o विश्लेषण (व्यावहारिक सलाहकार)

बहु-मॉडल विश्लेषण की शक्ति

वर्कफ़्लो का कार्यान्वयन

सेटअप निर्देश

व्यावहारिक उपयोग पैटर्न

त्वरित टेबल विश्लेषण

विभिन्न मॉडल दृष्टिकोणों की तुलना करें

कई टेबल का विश्लेषण करें

इंडेक्स विश्लेषण

क्वेरी प्रदर्शन विश्लेषण

AIMLAPI DBAs के लिए इसे क्यों संभव बनाता है

मॉडल चयन गाइड

MySQL से परे: अन्य CLI उदाहरण

सिस्टम प्रशासन

फ़ाइल और डायरेक्टरी विश्लेषण

लॉग विश्लेषण

कस्टम सिस्टम प्रॉम्प्ट

स्वचालित रिपोर्टिंग

प्रदर्शन अनुकूलन वर्कफ़्लो

इस दृष्टिकोण के वास्तविक लाभ

सर्वोत्तम परिणामों के लिए सुझाव

आज ही शुरुआत करना

Windows उपयोगकर्ता (त्वरित विकल्प)