Content
# Tool List
Systematically organize AI learning notes, paper readings, technical practices, and best practices.
## Covered Directions
- 📐 Fundamentals — ML / DL / Reinforcement Learning / Probability Statistics / Cognitive Science
- 🧠 LLM — Large Language Model principles, fine-tuning, deployment
- 🤖 AI Agent — LangGraph / LangChain / Multi-Agent architecture
- 🔍 RAG — Retrieval-Augmented Generation, vector databases, Embedding strategies
- 🔗 Knowledge Graph — Graph databases, knowledge representation and reasoning, Graph RAG
- 🎭 Multimodal — VLM, speech technology, video understanding, image generation
- 🔌 MCP — Model Context Protocol access and tool integration
- ✍️ Prompt Engineering — Prompt design patterns and optimization techniques
- 🛠️ Engineering Practice — AI application architecture, performance, observability
- 🌐 AI Search — Perplexity-style search, Web Browsing Agent, real-time information retrieval
- 📊 Data Engineering — Data collection, labeling, synthetic data, data flywheel
- 🧪 AI Testing — LLM testing, Prompt regression, Red Teaming, Agent end-to-end testing
- 🔐 AI Ethics and Governance — Bias fairness, explainability, regulatory compliance, responsible AI
- 💰 AI Product and Commercialization — Product design, pricing strategy, growth model, competitor analysis
- 🔬 Frontier Research — Autonomous Agent, Agent OS, embodied intelligence, scientific discovery
- 🏭 Industry Applications — Vertical domain landing in finance, healthcare, law, education, etc.
## Directory Structure
```
docs/
├── fundamentals/ # 📐 Fundamentals
├── llm/ # 🧠 Large Language Model
├── ai-agent/ # 🤖 AI Agent architecture
├── rag/ # 🔍 Retrieval-Augmented Generation
├── knowledge-graph/ # 🔗 Knowledge Graph
├── multimodal/ # 🎭 Multimodal technology
├── mcp/ # 🔌 Model Context Protocol
├── prompt-engineering/ # ✍️ Prompt engineering
├── engineering-practice/ # 🛠️ Engineering practice
├── ai-search/ # 🌐 AI Search and information retrieval
├── data-engineering/ # 📊 Data engineering and data flywheel
├── ai-testing/ # 🧪 AI Testing and quality assurance
├── ai-ethics/ # 🔐 AI Ethics and governance
├── ai-product/ # 💰 AI Product and commercialization
├── frontier-research/ # 🔬 Frontier research
└── industry-applications/ # 🏭 Industry applications
```
## Prompt Inquiry
How to ask AI questions to obtain high-quality knowledge learning documents.
### Core Principles
**Give AI enough constraints, not enough freedom.** The more ambiguous the question, the easier AI will give you "correct but useless" general talk. You need to limit the output **structure, depth, and style**.
### Universal Inquiry Template
```
Please generate an in-depth learning document about [topic].
Requirements:
1. Target audience: [your level, e.g., "backend developer with X years of experience"]
2. Document structure:
- Explain it in one sentence
- What problems it solves (what would happen without it)
- Core principles (use analogies or diagrams to help understand)
- Key concepts broken down one by one
- Practical code examples (use [language], scenario close to real business)
- Common pitfalls and mistakes
- Comparison with related technologies (e.g., [technology A] vs [technology B])
- A knowledge brain map summary
3. Style: concise and direct, avoid using technical terms, use "why" to connect logic
4. Length: [approximately how many words / how detailed]
```
### Scenario Variations
#### 1. Understanding a Concept from Scratch (Beginner)
```
I have no knowledge of [concept]. Please write a document in a way that "explains it to a smart outsider."
- Use a life analogy to explain the core idea
- Gradually introduce technical details
- Explain each new term immediately
- Provide a minimal runnable demo
```
#### 2. Deep Dive into Underlying Principles (Advanced)
```
I already know how to use [technology/framework], but I want to understand how it works under the hood. Please write a document:
- Explain [specific mechanism] from the source code/protocol level
- Draw the execution sequence diagram of key processes
- Explain why the designer made this design (what trade-offs are there)
- Compare with other implementation schemes
```
#### 3. Interview Preparation
```
Please help me prepare for [topic] interviews:
- Provide a complete knowledge system (brain map)
- List high-frequency interview questions (graded by difficulty)
- Provide "passing answers" and "bonus answers" for each question
- Mark which points are easily followed up, and what the follow-up directions are
```
#### 4. Horizontal Comparison (Selection/Decision)
```
Please compare [A] and [B] (optional: and [C]):
- Compare core dimensions in a table (performance/usability/ecology/ applicable scenarios)
- Respective typical usage scenarios
- When to choose A, when to choose B
- Migration cost and learning curve
- Provide your recommendation and reason
```
### Key Techniques to Improve Quality
| Technique | Example |
|---|---|
| **Declare your background** | "I have 3 years of Go development experience, familiar with Kafka" → AI will skip basic nonsense |
| **Specify output format** | "Use Markdown, include code blocks and tables" → clearer structure |
| **Require analogy** | "Use a restaurant ordering analogy to explain" → abstract concepts easier to understand |
| **Require counterexample** | "Provide incorrect and correct usage comparisons" → deeper impression |
| **Limit length** | "Around 3000 words" → avoid lengthy and boring content |
| **Follow-up instead of re-questioning** | After the first round of generation, ask follow-up questions for weak links, e.g., "The third part of XX is not clear, explain it in detail" |
### Practical Example
Learning **Go's Context**:
```
Please write an in-depth learning document about Go Context.
Background: I have 3 years of Go development experience, daily writing microservices, used context but not in-depth understanding.
Requirements:
1. Explain the essence of context in one sentence
2. Use a practical scenario (e.g., HTTP request chain) to illustrate what problems would occur without context
3. Explain the implementation principles of 4 types of context at the source code level
4. Context propagation mechanism in goroutine tree, draw a propagation diagram
5. Best practices and common anti-patterns (at least 5)
6. High-frequency interview questions and reference answers
7. Use Markdown format, code in Go, around 3000 words
```
> **Summary**: Poor inquiry → "Please introduce X"; good inquiry → tell AI **who you are, what you want, structure, depth, and style**. The more precise constraints you provide, the more useful AI's output will be.
## 🚢 Deployment and Synchronization
### Push to Remote Server
Use rsync to push the project to the remote server, automatically excluding unnecessary files:
```bash
rsync -avz \
--exclude='.git/' \
--exclude='.github/' \
--exclude='__pycache__/' \
--exclude='*.pyc' \
--exclude='venv' \
/Users/ziwh666/GitHub/ai-knowledge \
root@182.43.22.165:/data/github/
```
### Pull Latest Code from Remote
```bash
git fetch origin && git reset --hard origin/main
```
