Knowledge Management: How I Built an "Interview Second Brain" Using Obsidian + AI (With Bi-directional Link Graph)

In today's competitive job market, using AI for preparation is no secret. However, most job seekers using ChatGPT or Claude for Obsidian interview preparation fall into an inefficient cycle: struggling with vague, generic advice and repeatedly feeding the same resume data. The root of this frustration is not AI's lack of intelligence, but general LLMs' lack of deep contextual understanding of your career—they possess vast internet knowledge but know nothing of your unique project experiences, soft skills, and past reflections. This is the core value of building an Obsidian AI Interview Second Brain. By integrating Obsidian RAG (Retrieval-Augmented Generation) into your personal knowledge base, we upgrade AI from a mere external chatbot to a private interview coach that deeply reads your local LLM notes and understands every work detail. With advanced Obsidian AI plugins like Smart Connections, your Obsidian knowledge base chat moves beyond standard textbook answers to generate precise, grounded responses based on your actual past records. This highly customized Obsidian AI workflow eliminates LLM "hallucinations" and, through efficient Obsidian resume management, helps you quickly retrieve specific project metrics and decision logic during high-pressure interviews, transforming scattered notes into persuasive performance and demonstrating irreplaceable professional depth.

Core Concept: Why Can't General AI Handle Interview Preparation?

Many job seekers encounter a frustrating "goldfish memory" problem when trying to use ChatGPT or Claude for mock interviews: unless you re-paste your resume and project experience in every new conversation window, the AI knows nothing about you. When you ask, "How is my answer?", it can only give vague, generic advice because it lacks contextual understanding of your past experiences.

This is determined by the nature of general large models—they are trained on massive amounts of public internet data and possess rich general knowledge, but know nothing about your private data (your specific project details, salary expectations, soft skill traits). As Chris Lettieri pointed out in his practice, AI is not magic; data is the key. If isolated personal notes cannot be connected with AI's reasoning capabilities, even the most advanced models cannot become qualified interview coaches.

To solve this problem, we need to introduce a technical concept called RAG (Retrieval-Augmented Generation). In the context of Obsidian, this doesn't require you to become a technical expert to train models, but rather to give AI an "external brain" through plugins.

• General AI (No Context): When you ask "How do I introduce my React project?", it gives you a textbook-based standard template that is hollow and cookie-cutter.
• Interview Second Brain (Obsidian + RAG): When you ask the same question, the AI first retrieves the review records regarding the "E-commerce Refactoring Project" from your vault, and then answers: "Based on the performance optimization challenges recorded in your notes, it is suggested that you highlight how you reduced the first screen load time by 40% through code splitting, which is more persuasive than talking broadly about React features."

In this way, we transform AI from a general chatbot that only speaks in platitudes into a personalized interview coach that is intimately familiar with all your past experiences. In the following section, we will delve into how this technology is implemented without writing code.

Say Goodbye to "Generic Fluff": How RAG Technology Helps AI Understand Your Resume

Many people feel a sense of frustration when using ChatGPT to prepare for interviews because the AI's responses are full of "correct fluff." When you ask it, "How should I answer the question 'What was your biggest challenge?'", it gives you a standard STAR method template but fails to mention the high-concurrency refactoring project you led at your previous company.

This is because generic AI models do not possess your "memories." To solve this problem, we need to introduce RAG (Retrieval-Augmented Generation) technology.

Your Notes Are AI's "External Brain"

Simply put, RAG technology allows AI to flip through your private notes stored in Obsidian before answering a question. It's like turning a "closed-book exam" into an "open-book exam."

In this workflow, when you ask a question to an AI plugin within Obsidian, these three steps actually happen in the background:

1. Retrieval: The plugin first analyzes your question (e.g., "Summarize the technical difficulties I faced in the ABC project") and performs a semantic search in your local note vault to find the few notes most relevant to that question (such as "2023-ABC Project Review", "Technical Architecture Diagram").
2. Augmentation: The plugin packages these specific note contents as "background knowledge" and sends them along with your original question to the AI model.
3. Generation: After reading these background materials, the AI generates an answer based on your real experiences, rather than fabricating nonsense based on generic knowledge learned from large model training data.

As pointed out by industry experts, RAG essentially gives AI a "real-time database," allowing it to converse with you like a personal coach who is familiar with all your past experiences.

Practical Comparison: Generic AI vs. Second Brain

To visually demonstrate this difference, let's look at a specific interview scenario comparison. Assume your note vault contains a project review note regarding "payment system high-concurrency optimization."

Interview Question: "Please describe a difficult challenge you encountered in a technical project."

Why Is This Crucial for Interviews?

In interview preparation, the hardest part is often not "not knowing how to say it," but "forgetting what you have done."

Through RAG technology, your Obsidian vault becomes a hallucination-proof verification system. When you ask the AI, "What other projects in my resume demonstrate cross-departmental collaboration skills?", it won't feed you generic workplace platitudes. Instead, it will precisely dig out the "Cross-Team API Integration Meeting Minutes" you recorded six months ago, reminding you how you coordinated with backend and mobile teams to resolve interface data inconsistencies.

This fact-based Feedback Loop allows you to quickly build confidence during mock interviews because every word you say is documented and represents your accumulated real experience.

Setup Guide: Build Your AI Interview Coach in Three Steps

Many job seekers are often discouraged by complex command lines (CLI) and programming jargon when they see "building a second brain" or "deploying a local LLM." In fact, within the Obsidian ecosystem, using mature plugins to implement RAG (Retrieval-Augmented Generation) functionality is already very simple and requires absolutely no coding.

Here are the three core steps to build your personalized AI interview coach. This "low-code" solution allows you to complete the environment setup within 10 minutes, letting you focus your energy on preparing content rather than debugging tools.

1. Structure Your "Interview Corpus" (Structure Data)
   The quality of AI answers depends on the quality of data you feed it. Do not stuff all your experiences into one huge text document; instead, you should utilize Obsidian's file features for structured splitting:

• • Create a Dedicated Folder: Create a folder named 00InterviewContext to ensure the AI prioritizes this area during retrieval.
  • Atomize Your Resume: Split your resume into independent Markdown files, such as Resume_Summary.md (Personal Profile), ProjectADetails.md (STAR Review of Core Project A), and Skill_Stack.md (List of Tech Stack).
  • Clean Data: Ensure your notes contain specific metrics (e.g., "increased concurrency by 20%") and key technical terms, as these are the "anchors" for the AI to establish context connections.

1. Install Core RAG Plugins (Install RAG Plugin)
   You need a plugin that can understand the semantics of your notes. Currently, there are two mainstream choices in the community that require no programming:

• • Smart Connections: This is a plugin focused on bringing AI to your Obsidian vault. Its core advantage is its powerful semantic search capability, which can accurately find note segments related to your current question, and the basic features are free.
  • Copilot for Obsidian: If you prefer a sidebar chat experience similar to ChatGPT, Copilot for Obsidian is a more polished choice. It not only supports chatting with notes but also has a friendlier UI, making it suitable for users who don't want to fuss with configurations.
  • Configure API Key: After installation, you usually need to enter an OpenAI or Claude API Key in the plugin settings. This is the only "technical threshold" to connect to large models, which can be obtained simply by registering an account with the corresponding service provider.

1. Build Index and Start Chatting (Index & Chat)
   After the plugin is installed, the most critical step is to let the AI "read" your notes:

• • Generate Embeddings: Click "Create Embeddings" or "Index Vault" in the plugin panel. This step converts your local notes into vector data, allowing the AI to understand the logical relationships between notes, rather than just keyword matching.
  • Verification Test: After indexing is complete, open the chat window and input a question where only you know the details to test it. For example: "According to my Project_A note, what strategy did I use when handling high concurrency?"
  • If the AI can accurately recount the technical details in your notes, it means your "Interview Second Brain" has been successfully activated.

Expert Tip: According to third-party comparison reviews, if you focus on quickly discovering connections between notes, Smart Connections performs better in semantic search; however, if you need AI to help you deeply polish your resume or engage in long-text conversations, Copilot may offer a smoother experience. It is recommended to choose one based on your specific preparation needs.

Step 1: Atomic Notes—"Slicing" Your Resume and Project Experience

When attempting to use AI to assist with interview preparation, the most intuitive approach for many is to directly "feed" a complete PDF resume or a ten-page project document to the AI. However, in practice, I have found that this crude "feeding" method often yields poor results: when asked about details, the AI is prone to hallucinations or confusing the tech stacks of different projects because it faces a large, cluttered chunk of context during retrieval.

To build a precise "Interview Second Brain," the core lies in the structuring of data. I adopt the Atomic Notes strategy—breaking down every core experience, project, or skill point in the resume into independent and interconnected Markdown files.

Why "Slice"?

AI's Retrieval-Augmented Generation (RAG) mechanism is similar to "flipping through a book" in this vast repository. If you give it a thick book written with everything (a huge document), it struggles to quickly flip to a specific page. But if you organize the materials into labeled folders (Atomic Notes), the AI can precisely retrieve the most relevant page, thereby greatly reducing the probability of fabrication.

Concrete Breakdown Plan

Don't put all your eggs in one basket. I suggest restructuring your Obsidian vault according to the following logic:

1. Establish a "Master Node": Create a note named [[MyResumeMaster]]. Do not write specific details here; it serves only as a directory index.
2. Isolate Project Experience:

• • Wrong approach: Describing the "E-commerce Refactoring Project" with 500 words within the resume file.
  • Correct approach: Create an independent note [[ProjectEcommerceRefactoring_System]]. In this file, record in detail the project background, STAR method stories, technical challenges, architecture diagrams, and quantitative data.

1. Splitting Skills and Soft Skills:

• • Create separate notes for each core skill (e.g., [[SkillRedisOptimization]]) or behavioral interview scenario (e.g., [[StoryTeamConflict_Resolution]]).

The Power of Links

After completing the breakdown, use bidirectional links in [[MyResumeMaster]] to connect them:

- 2021-2023 Senior Backend Engineer
- Responsible for core transaction link refactoring (see [[ProjectEcommerceRefactoring_System]])
- Introduced caching strategies to reduce latency (see [[SkillRedisOptimization]])
- Led a 5-person team to complete agile transformation (see [[StoryTeamLeadership]])

Through this structure, when you ask the AI, "Regarding my e-commerce project, what high-concurrency questions about Redis might the interviewer ask?", the AI can precisely lock onto the two specific files [[ProjectEcommerceRefactoring_System]] and [[SkillRedisOptimization]] as context via the path, rather than being interfered with by an irrelevant project you did at another company five years ago. This "slicing" process is the critical first step in evolving the AI from "speaking generally" to "expert-level sparring."

Step 2: Plugin Selection—Smart Connections and Common Tool Configuration

After completing the organization of "Atomic Notes," we need a tool capable of "reading" these notes and answering questions based on them. This is what the tech community calls RAG (Retrieval-Augmented Generation)—simply put, it gives AI the memory of your private notes, rather than relying solely on general internet knowledge to answer.

There are countless AI plugins for Obsidian on the market, but for the specific scenario of interview preparation, we don't need complex automated writing functions. There is only one core requirement: accurately retrieve my past experiences and simulate interviews based on them.

Here are the recommended tool combinations that have been battle-tested and are the easiest to configure:

1. Preferred Solution: Smart Connections

This is currently the plugin with the lowest barrier to entry and the best results for "chatting with notes." Its core value lies in its ability to automatically create indexes (Embeddings) for every note in your vault.

• Core Function: When you ask in the sidebar, "Based on my resume, what was the trickiest concurrency issue I handled?" it won't hallucinate. Instead, it will first retrieve relevant "Atomic Notes" from your vault and then generate an answer combined with the context.
• Configuration Advice:
• • Model Selection: It is recommended to use the API Key for OpenAI GPT-4o or Claude 3.5 Sonnet directly. Although the plugin supports Local Models, for the sake of efficiency in interview preparation and the logical depth of answers, cloud-based models perform far better than local ones. Moreover, the pay-as-you-go cost is usually much lower than the time cost of tinkering with a local environment.
  • Enable RAG: Be sure to confirm in the settings that "Chat with Notes" or a similar option is enabled. This is key to distinguishing it from the standard ChatGPT web version.

2. Alternative Solution: Copilot (for Obsidian)

If you are more accustomed to a native interface similar to ChatGPT, the Copilot plugin is another excellent choice. Its advantage lies in its very smooth interface interaction and support for referencing the currently open note with one click.

• Applicable Scenarios: When you need to deeply polish a single specific project document (e.g., "Optimize the STAR description in this 'High Concurrency Flash Sale System' note"), Copilot's "Reference Current Note" feature is very handy.

3. Pitfall Guide: Refuse "Over-engineering"

When browsing related tutorials, you might see many geeks recommending the use of Python scripts, LangChain, or complex local knowledge base deployment solutions.

Please be sure to resist this urge.

Your goal is to get the Offer, not to become a Large Language Model application engineer.

• Do not tinker with local deployment (Ollama, etc.) just to save a few dollars on API fees. Unless your computer specs are extremely high and you are already an expert in this field, the response speed and logical capability of local models often cannot meet the high-pressure demands of mock interviews.
• Do not write complex automation scripts. Directly install the aforementioned out-of-the-box plugins, enter the API Key, and spend your time polishing your interview stories.

Once configured, your Obsidian is no longer just a static notebook, but an intelligent assistant loaded with all the details of your career. Next, we can move on to the practical phase to see how to direct this assistant to optimize your interview performance.

Practical Scenario 1: Deep Optimization of STAR Interview Stories

In interview preparation, the biggest pain point is often not "having not done projects," but "being unable to narrate projects logically." Many engineers, when reviewing their experiences, easily fall into the quagmire of technical details or ignore background context due to the "curse of knowledge."

By utilizing Obsidian's RAG (Retrieval-Augmented Generation) capabilities, we can standardize this process. Instead of staring at a blank document and recalling memories tediously, it is better to use AI as a strict interview coach. Based on the atomic notes you have already organized, it can help you polish high-scoring stories that conform to the STAR method (Situation, Task, Action, Result).

1. From "Laundry List" to Structured Storytelling

First, open an atomic note for a specific project (e.g., [[Project Alpha - High Concurrency Refactoring]]). Open the AI chat window in the sidebar (such as Smart Connections or Copilot); at this point, the AI has already read the context of the current note.

You can use the following Prompt to let AI help you complete the structuring of the first draft:

Prompt Example:
"Read the current note regarding [[Project Alpha]]. As a senior technical interviewer, please rewrite this experience into a standard STAR interview response.
Requirements:
1. Situation: Summarize the business background and technical difficulties in one sentence.
2. Task: Clarify my core responsibilities within it.
3. Action: List the key technical decisions I made, using logical connectors like 'first, second, third'.
4. Result: Emphasize quantitative benefits (e.g., QPS increase, cost reduction percentage)."

This method can instantly connect scattered technical points into a logical thread, ensuring you possess a clear framework before you even open your mouth.

2. Using AI to Find Logical Loopholes (Gap Analysis)

First drafts are often imperfect. When narrating their own stories, humans often subconsciously embellish the process or omit key data. At this point, you need to switch the AI's role from a "writer" to a "critic."

In interviews, the most fatal flaw is often the absence or vagueness of the Result section. Many candidates only say "optimized performance" without stating specifically how much it improved. You can continue to ask:

Prompt Example:
"Based on the STAR story above, please point out what key details are missing from my narrative? Especially regarding the 'Result' section, have I provided enough quantitative evidence? If not, please infer possible data metrics based on the note content, or suggest what specific monitoring data I need to supplement."

The AI might keenly point out: "You mentioned introducing Redis caching, but didn't explain what the cache hit rate was, nor did you compare the P99 latency changes before and after implementation." This feedback forces you to trace back through code or monitoring logs to fill in the blanks of real data, thereby greatly enhancing the credibility of the story.

3. Simulating Stress Interviews: Predicting Follow-up Questions

A good STAR story is just the beginning; high-level interviews often consist of a series of in-depth Follow-up Questions. Using your "second brain," you can rehearse this battle of wits.

Since Obsidian's AI plugins can index all your technical notes, you can let it combine your tech stack (e.g., [[Java]], [[Microservices]]) to generate highly targeted questions:

Prompt Example:
"Assume you are a Google L5 level backend engineer interviewing me. Based on my description of [[Project Alpha]], please ask 3 challenging deep-dive questions. Focus on examining my trade-offs in system design and exception handling mechanisms."

The AI might ask: "In the Action step, you chose a message queue for load leveling. If the message backlog exceeds 1 hour, what is your fallback strategy?"

In this way, you are not just reciting a story, but building a defense system around the project. By adding these high-quality follow-up questions generated by AI and their answers back into your project notes, your "interview second brain" will become increasingly robust and intelligent with every conversation.

Practical Scenario 2: Realistic Mock Interview (Mock Interview)

The original intention of building a "Second Brain" is not merely for static storage, but more importantly, to make this knowledge "come alive" at critical moments. In interview preparation, the core pain point is often not the inability to remember knowledge points, but the inability to fluently invoke this knowledge during high-pressure conversations. By utilizing Obsidian's AI plugins (such as Copilot for Obsidian or Vault Chat), we can transform static notes into a "mock interviewer" that is online 24/7.

Setting up the AI Interviewer Persona (Persona Setup)

Generic AI conversations are often too gentle and lack the pressure of a real interview. To solve this problem, I preset a specific persona in the plugin's System Prompt.

For example, if I am preparing for a Product Manager interview at a major tech company, I would configure the Prompt like this:

Role: You are a Senior Product Manager interviewer at Google, with a strict style, focusing on data support and logical consistency.
Context: Please read my [[Resume.md]] and [[ProjectAlphaReview.md]].
Task: Regarding the "User Growth Strategy" section mentioned in my resume, ask three challenging follow-up questions. If my answer lacks specific metrics, interrupt me directly and point out my logical loopholes.

This setting forces the AI to step out of "Assistant" mode and enter "Examiner" mode. It is no longer helping you polish your text, but trying to find flaws in your logic.

Targeted Pressure and Consistency Checking

A very typical practical usage is to conduct pressure tests against "weaknesses." I maintain a [[Weaknesses.md]] (weakness analysis) in my vault, which truthfully records the weak links in my tech stack or regrets in my projects.

During the simulation session, I send instructions to the AI:

"Based on my [[Weaknesses.md]], simulate an interview scenario: Assume you have discovered this shortcoming on my resume. Please ask a question in a tricky way to see how I defend myself."

After I input my answer, the value of the AI lies in the Consistency Check. It can quickly compare my colloquial answer (Verbal Response) with the actual project details recorded in my notes to see if there is a conflict. For example, the AI might point out: "You claimed in your answer to have a deep understanding of high concurrency, but in your [[Project_Architecture.md]] note, you recorded a downtime incident caused by database lock contention at that time, and did not mention a thorough solution. This inconsistency would be considered an integrity issue in a real interview."

This "Red Teaming" style feedback allows you to complete self-repair in a safe sandbox environment before the real interviewer discovers the loopholes. Next, if the interviewer digs deeper into technical details, we need to call upon a deeper knowledge network to respond.

Knowledge Graph Associations: How to Handle Follow-up Questions on Technical "Rote" Topics

In technical interviews, the biggest headache is often not the opening standard questions (commonly known as "baguwen" or rote questions), but the deep follow-up questions that ensue. Interviewers usually use a basic concept (such as "Redis") as an entry point, then expand horizontally into architectural design, or dig vertically into underlying principles. If you have only memorized isolated knowledge points, it is easy to appear hesitant during the follow-up phase.

Leveraging Obsidian's core advantages—Bi-directional Links and Knowledge Graph—combined with AI's semantic understanding capabilities, we can build a dynamic "Knowledge Network" rather than a static question bank. This helps you train the ability to "draw inferences" during mock interviews.

1. Breaking Information Silos with Semantic Search (Smart Connections)

Traditional review methods are linear, while interview conversations are divergent. I use Smart Connections or similar Embedding-based plugins to simulate this divergence. These tools go beyond keyword matching; by understanding the semantic relationships within your note content, they identify logical connections you might have overlooked.

Practical Operation:
In a mock interview, when the AI interviewer throws out a core concept, do not rush to answer with a definition. Instead, use the AI's "Lookup" or "Chat with Vault" feature to check which notes are associated with that concept in your knowledge base.

2. Scenario Demonstration: The Mental Leap from "Point" to "Network"

Suppose the interviewer asks: "How is Redis used in your projects?"

• Ordinary Answer (Linear): Listing the five data structures of Redis (String, Hash, List...), which is a typical "recitation" mode.
• AI-Assisted Associative Answer (Networked):
  When you input "Redis", the AI plugin instantly pushes highly relevant notes based on your note library, such as Cache Consistency Strategies, Distributed Lock Implementation, or Solutions for Cache Avalanche under High Concurrency.

Seeing these association prompts, your answering strategy can be immediately adjusted to:
> "We mainly use Redis to handle high-frequency read/write operations in our projects. In addition to basic data caching, we combine Distributed Locks (Associated Note A) to ensure operation atomicity; meanwhile, to solve the inconsistency problem between the database and cache, we adopted the Delayed Double Deletion (Associated Note B) strategy..."

This way of answering demonstrates your complete understanding of the technical system, elevating your perspective directly from a "User" to an "Architect."

3. Training "Follow-up Prediction" Capabilities

As Andrew Lukyanenko mentioned in his machine learning interview experience, while manually establishing links is time-consuming, it allows you to easily explore related concepts during review. Combined with AI, we can go a step further and actively ask the AI to pose "aggressive" questions:

Prompt Example:
"Based on my notes regarding 'Microservice Architecture' and the strongly associated 'CAP Theorem' note, please generate 3 highly challenging follow-up questions requiring me to explain the trade-offs between the two."

In this way, you are no longer passively waiting for questions but using the proactivity of the knowledge graph to anticipate the interviewer's thought path. The establishment of this "Knowledge Network" ensures that when facing difficult technical follow-ups, you can always find the next pivot point to expand upon, avoiding awkward silences.

Advanced Configuration: Local LLM and Privacy & Security

In the process of building an "Interview Second Brain," privacy and security is a critical "red line" issue that cannot be ignored. When your Obsidian vault stores resumes containing real salary expectations, project reviews involving former employers' trade secrets (NDAs), or even personal weakness analyses, directly calling cloud APIs (such as OpenAI or Claude) may bring risks of data leakage.

For job seekers pursuing ultimate privacy and data sovereignty, Local Large Language Models (Local LLMs) are the safest solution. By running models locally, you can ensure that not a single character leaves your computer, achieving "air-gapped" level security.

Why Choose Local Models?

Although cloud models like GPT-4 excel in logical reasoning and creative writing, in interview preparation scenarios, we mainly rely on RAG (Retrieval-Augmented Generation) capabilities—that is, letting AI "browse" through information in your notes and summarize it.

For such fact-based retrieval tasks, local small models (such as Llama 3 8B or Mistral) are completely sufficient. Although they may appear a bit "dumber" (weaker generalization ability), their performance often exceeds expectations when handling instructions like "answer this project challenge based on my notes," and they are completely free and require no internet connection.

Core Toolchain: Ollama + Obsidian

Currently, the most mainstream and accessible local deployment solution is Ollama combined with Obsidian plugins.

1. Backend Support (Ollama):
   Ollama is an open-source tool that allows you to run open-source models on macOS, Linux, or Windows with one click. After installation, simply enter a simple command in the terminal (such as ollama run llama3) to start an API service locally.

• • Recommended Models: For most laptops (especially those with Apple M-series chips), Llama 3 (8B) or Mistral is recommended. These two models strike an excellent balance between performance and resource usage, typically requiring only 8GB-16GB of RAM to run smoothly.

1. Frontend Connection (Plugin Configuration):
   Most mainstream AI plugins (such as Smart Connections or Copilot) support connection via a local server.

• • In the plugin settings, select Ollama or Local as the LLM Provider.
  • The server address usually defaults to http://localhost:11434.
  • Once connected successfully, the plugin will no longer send requests to OpenAI but will directly utilize your computer's computing power.

Performance Trade-offs and Hardware Thresholds

While using local models ensures absolute security, it also requires facing some realistic trade-offs:

• Hardware Dependency: Local inference relies heavily on the computer's GPU and RAM. If you are using an older Intel-based MacBook or a Windows laptop without a dedicated graphics card, generation speed may be significantly slower than cloud APIs, or even experience lag.
• Intelligence Level: Local models (typically 7B-14B parameters) cannot handle extremely complex logical traps like GPT-4 (trillion-level parameters). For example, during high-difficulty mock interviews, it might occasionally "spout nonsense" or fail to understand deep subtext.
• Context Limitations: The context window of local models is usually smaller. If you "feed" it dozens of long documents at once, it might suffer from "indigestion" or forget previous content.

Security Advice: If your device performance is insufficient to run local models but you must handle sensitive data, it is recommended to adopt a tiered strategy. Use local models to process notes involving core privacy issues like salaries and architecture diagrams; for general Behavioral Questions or technical concept reviews that do not contain sensitive information, you can still use cloud models to obtain a better experience.