MCP Stack - Vector Memory System for AI Development

1. Summary

This repository provides a comprehensive vector memory system for AI-assisted development using the Model Context Protocol (MCP). It creates a persistent, searchable knowledge base divided into four specialized collections:

• Documentation Memory: Official API documentation and reference materials
• Code Examples: Practical implementation patterns and working code samples
• Project Context: Project-specific knowledge, conventions, and architectural decisions
• Technical Knowledge: General software engineering concepts and best practices

The stack uses Qdrant as the vector database backend and integrates with various AI tools through MCP servers, enabling AI assistants to store and retrieve contextual information effectively.

2. Qdrant Service Description

Core Components

• Qdrant Server: High-performance vector database that stores embeddings and metadata

  • REST API: http://localhost:6333 or http://qdrant.localhost.loc (via Traefik)
  • gRPC API: http://localhost:6334
  • Persistent storage in Docker volume

• Qdrant Web UI: Administrative interface for managing collections and data

  • Access at: http://localhost:5050 or http://qdrant-ui.localhost.loc (via Traefik)
  • View collections, perform searches, manage data

Starting the Services

# Start only Qdrant and UI
docker-compose up -d

Add to /etc/hosts for Traefik URLs:

127.0.0.1 qdrant.localhost.loc, qdrant-ui.localhost.loc, traefik.localhost.loc

cat <<- 'EOF' >> /etc/hosts
127.0.0.1 qdrant.localhost.loc, qdrant-ui.localhost.loc, traefik.localhost.loc
'EOF'

3. Configuration for Claude Code

Prerequisites

• Python environment with virtual environment activated agentic configured: pyenv activate agentic
• LM Studio running with text-embedding-nomic-embed-text-v1.5-embedding model loaded and configured to listen on port 11433 (or default port modify configuration LMSTUDIO_API_BASE)
• Qdrant server running (see above)
• Your agentic tool. E.g.: Claude Code

Option A: Using Claude MCP CLI

# 1. Documentation Memory
claude mcp add code-documentation
  -e QDRANT_URL="http://qdrant.localhost.loc"
  -e COLLECTION_NAME="code-documentation"
  -e EMBEDDING_PROVIDER="lmstudio"
  -e EMBEDDING_MODEL="text-embedding-nomic-embed-text-v1.5-embedding"
  -e EMBEDDING_VECTOR_SIZE="768"
  -e LMSTUDIO_API_BASE="http://localhost:11433/v1"
  -e LMSTUDIO_API_KEY="lm-studio"
  -e TOOL_STORE_DESCRIPTION="Store API documentation, reference materials, and standard usage patterns.
          This memory store is for OFFICIAL documentation content such as function signatures, parameter details, 
          return types, error codes, and usage requirements. Include structured metadata: metadata.type ('api-reference', 
          'function-doc', 'class-doc', 'error-docs', 'deprecation-notice'), metadata.language (programming language), 
          metadata.framework (library/framework name), metadata.version (specific version number), metadata.source 
          (e.g., 'context7', 'official-docs'), metadata.timestamp (ISO date), and metadata.keywords (search terms).
          DO NOT store project-specific code, examples, or general technical concepts here - only official reference 
          material. When storing from context7, mark metadata.source accordingly."
  -e TOOL_FIND_DESCRIPTION="Search for official API documentation before implementing code. Use this tool to 
          verify exact function signatures, parameter requirements, return types, and accepted values before writing code. 
          Particularly useful for: 1) Checking API details for correct implementation, 2) Confirming deprecation status 
          of methods, 3) Verifying breaking changes between versions, 4) Understanding error states and handling requirements. 
          This tool searches documentation-specific memory only. For implementation examples or project-specific code, 
          use the appropriate specialized memory tools instead. If documentation isn't found, use context7 to retrieve 
          the latest API documentation and IMMEDIATELY STORE it in this memory for future reference."
  -- bash -c "$(pyenv prefix agentic)/bin/python -m uvx mcp-server-qdrant"

# 2. Code Examples Memory
claude mcp add code-examples
  -e QDRANT_URL="http://qdrant.localhost.loc"
  -e COLLECTION_NAME="code-examples"
  -e EMBEDDING_PROVIDER="lmstudio"
  -e EMBEDDING_MODEL="text-embedding-nomic-embed-text-v1.5-embedding"
  -e EMBEDDING_VECTOR_SIZE="768"
  -e LMSTUDIO_API_BASE="http://localhost:11433/v1"
  -e LMSTUDIO_API_KEY="lm-studio"
  -e TOOL_STORE_DESCRIPTION="Store practical code EXAMPLES and implementation patterns.
          This memory is for concrete, working code samples that demonstrate how to accomplish specific tasks.
          Include structured metadata: metadata.type ('implementation-example', 'integration-pattern', 'algorithm-sample', 
          'error-handling', 'testing-pattern'), metadata.language (programming language), metadata.framework (framework used), 
          metadata.complexity ('basic', 'intermediate', 'advanced'), metadata.source (where example came from), 
          metadata.timestamp (ISO date), and metadata.keywords (search terms). ALWAYS include complete, runnable 
          code snippets with proper syntax. Focus on quality, idiomatic examples that follow best practices.
          When storing from context7, mark metadata.source accordingly and ensure examples are up-to-date."
  -e TOOL_FIND_DESCRIPTION="Search for practical code examples and implementation patterns before writing new code.
          Use this tool to find: 1) Working implementations of specific functionality, 2) Integration patterns between 
          systems or libraries, 3) Error handling patterns for specific operations, 4) Testing approaches for similar 
          functionality, 5) Algorithm implementations relevant to your task. This tool searches code examples memory only.
          For official API documentation or project-specific patterns, use the appropriate specialized memory tools instead.
          If no suitable examples are found, use context7 to find current implementations and IMMEDIATELY STORE them in 
          this memory with appropriate metadata for future reference."
  -- bash -c "$(pyenv prefix agentic)/bin/python -m uvx mcp-server-qdrant"

# 3. Project Context Memory
claude mcp add project-context
  -e QDRANT_URL="http://qdrant.localhost.loc"
  -e COLLECTION_NAME="project-context"
  -e EMBEDDING_PROVIDER="lmstudio"
  -e EMBEDDING_MODEL="text-embedding-nomic-embed-text-v1.5-embedding"
  -e EMBEDDING_VECTOR_SIZE="768"
  -e LMSTUDIO_API_BASE="http://localhost:11433/v1"
  -e LMSTUDIO_API_KEY="lm-studio"
  -e TOOL_STORE_DESCRIPTION="Store PROJECT-SPECIFIC knowledge, patterns, and decisions.
          This memory is for information specific to the current codebase such as architecture decisions, 
          custom patterns, project conventions, internal API interfaces, domain-specific terminology, and 
          implementation details unique to this project. Include structured metadata: metadata.type ('architecture-decision', 
          'project-pattern', 'internal-api', 'domain-knowledge', 'implementation-detail', 'project-convention'), 
          metadata.module (affected module or component), metadata.author (who provided this information), 
          metadata.timestamp (ISO date), and metadata.keywords (search terms). DO NOT store generic documentation 
          or examples here - only information specific to this project."
  -e TOOL_FIND_DESCRIPTION="Search for project-specific context and knowledge before making implementation decisions.
          Use this tool to: 1) Recall project architecture decisions, 2) Follow established project patterns and conventions, 
          3) Find internal API usages specific to this codebase, 4) Understand domain-specific terminology and concepts used 
          in this project. This tool searches project-specific memory only. For official documentation or general examples, 
          use the appropriate specialized memory tools instead. Project context is essential for maintaining consistency 
          with the existing codebase and ensuring new implementations align with established patterns."
  -- bash -c "$(pyenv prefix agentic)/bin/python -m uvx mcp-server-qdrant"

# 4. Technical Knowledge Memory
claude mcp add technical-knowledge
  -e QDRANT_URL="http://qdrant.localhost.loc"
  -e COLLECTION_NAME="technical-knowledge"
  -e EMBEDDING_PROVIDER="lmstudio"
  -e EMBEDDING_MODEL="text-embedding-nomic-embed-text-v1.5-embedding"
  -e EMBEDDING_VECTOR_SIZE="768"
  -e LMSTUDIO_API_BASE="http://localhost:11433/v1"
  -e LMSTUDIO_API_KEY="lm-studio"
  -e TOOL_STORE_DESCRIPTION="Store broader technical CONCEPTS, principles, and best practices.
          This memory is for general software engineering knowledge such as design patterns, architectural principles, 
          performance optimization techniques, security best practices, algorithmic approaches, and system design concepts.
          Include structured metadata: metadata.type ('design-pattern', 'security-practice', 'performance-principle', 
          'architecture-concept', 'algorithm-theory', 'best-practice'), metadata.domain (applicable domain), 
          metadata.source (where the knowledge came from), metadata.timestamp (ISO date), metadata.complexity 
          ('fundamental', 'intermediate', 'advanced'), and metadata.keywords (search terms). Focus on timeless 
          principles rather than specific implementations. Include explanations of WHY certain approaches are 
          recommended, not just HOW to implement them."
  -e TOOL_FIND_DESCRIPTION="Search for technical concepts, principles, and best practices to inform design decisions.
          Use this tool when you need: 1) Appropriate design patterns for a particular problem, 2) Security best practices 
          for a specific context, 3) Performance optimization principles, 4) Architectural approaches for system design, 
          5) General software engineering best practices. This tool searches technical knowledge memory only. For specific 
          implementations, API details, or project conventions, use the appropriate specialized memory tools instead.
          Technical knowledge provides the foundational understanding needed to make good design decisions and avoid 
          common pitfalls. If relevant knowledge isn't found, use context7 to retrieve established principles and 
          IMMEDIATELY STORE them for future reference."
  -- bash -c "$(pyenv prefix agentic)/bin/python -m uvx mcp-server-qdrant"

Option B: Using settings.json

Add to your .claude/settings.local.json or global settings:

{
  "mcp": {
    "code-documentation": {
      "command": "bash",
      "args": ["-c", "$(pyenv prefix agentic)/bin/python -m uvx mcp-server-qdrant"],
      "env": {
        "QDRANT_URL": "http://qdrant.localhost.loc",
        "COLLECTION_NAME": "code-documentation",
        "EMBEDDING_PROVIDER": "lmstudio",
        "EMBEDDING_MODEL": "text-embedding-nomic-embed-text-v1.5-embedding",
        "EMBEDDING_VECTOR_SIZE": "768",
        "LMSTUDIO_API_BASE": "http://localhost:11433/v1",
        "LMSTUDIO_API_KEY": "lm-studio",
        "TOOL_STORE_DESCRIPTION": "Store API documentation, reference materials, and standard usage patterns. This memory store is for OFFICIAL documentation content such as function signatures, parameter details, return types, error codes, and usage requirements. Include structured metadata: metadata.type ('api-reference', 'function-doc', 'class-doc', 'error-docs', deprecation-notice'), metadata.language (programming language), metadata.framework (library/framework name), metadata.version (specific version number), metadata.source 
          (e.g., 'context7', 'official-docs'), metadata.timestamp (ISO date), and metadata.keywords (search terms). DO NOT store project-specific code, examples, or general technical concepts here - only official reference material. When storing from context7, mark metadata.source accordingly.",
        "TOOL_FIND_DESCRIPTION": "Search for official API documentation before implementing code. Use this tool to verify exact function signatures, parameter requirements, return types, and accepted values before writing code. Particularly useful for: 1) Checking API details for correct implementation, 2) Confirming deprecation status of methods, 3) Verifying breaking changes between versions, 4) Understanding error states and handling requirements. This tool searches documentation-specific memory only. For implementation examples or project-specific code, use the appropriate specialized memory tools instead. If documentation isn't found, use context7 to retrieve the latest API documentation and IMMEDIATELY STORE it in this memory for future reference."
      }
    },
    "code-examples": {
      "command": "bash",
      "args": ["-c", "$(pyenv prefix agentic)/bin/python -m uvx mcp-server-qdrant"],
      "env": {
        "QDRANT_URL": "http://qdrant.localhost.loc",
        "COLLECTION_NAME": "code-examples",
        "EMBEDDING_PROVIDER": "lmstudio",
        "EMBEDDING_MODEL": "text-embedding-nomic-embed-text-v1.5-embedding",
        "EMBEDDING_VECTOR_SIZE": "768",
        "LMSTUDIO_API_BASE": "http://localhost:11433/v1",
        "LMSTUDIO_API_KEY": "lm-studio",
        "TOOL_STORE_DESCRIPTION": "Store practical code EXAMPLES and implementation patterns. This memory is for concrete, working code samples that demonstrate how to accomplish specific tasks. Include structured metadata: metadata.type ('implementation-example', 'integration-pattern', 'algorithm-sample', 'error-handling', 'testing-pattern'), metadata.language (programming language), metadata.framework (framework used), metadata.complexity ('basic', 'intermediate', 'advanced'), metadata.source (where example came from), metadata.timestamp (ISO date), and metadata.keywords (search terms). ALWAYS include complete, runnable code snippets with proper syntax. Focus on quality, idiomatic examples that follow best practices. When storing from context7, mark metadata.source accordingly and ensure examples are up-to-date.",
        "TOOL_FIND_DESCRIPTION": "Search for practical code examples and implementation patterns before writing new code. Use this tool to find: 1) Working implementations of specific functionality, 2) Integration patterns between systems or libraries, 3) Error handling patterns for specific operations, 4) Testing approaches for similar functionality, 5) Algorithm implementations relevant to your task. This tool searches code examples memory only.
          For official API documentation or project-specific patterns, use the appropriate specialized memory tools instead.
          If no suitable examples are found, use context7 to find current implementations and IMMEDIATELY STORE them in 
          this memory with appropriate metadata for future reference."
      }
    },
    "project-context": {
      "command": "bash",
      "args": ["-c", "$(pyenv prefix agentic)/bin/python -m uvx mcp-server-qdrant"],
      "env": {
        "QDRANT_URL": "http://qdrant.localhost.loc",
        "COLLECTION_NAME": "project-context",
        "EMBEDDING_PROVIDER": "lmstudio",
        "EMBEDDING_MODEL": "text-embedding-nomic-embed-text-v1.5-embedding",
        "EMBEDDING_VECTOR_SIZE": "768",
        "LMSTUDIO_API_BASE": "http://localhost:11433/v1",
        "LMSTUDIO_API_KEY": "lm-studio",
        "TOOL_STORE_DESCRIPTION": "Store PROJECT-SPECIFIC knowledge, patterns, and decisions.
          This memory is for information specific to the current codebase such as architecture decisions, 
          custom patterns, project conventions, internal API interfaces, domain-specific terminology, and 
          implementation details unique to this project. Include structured metadata: metadata.type ('architecture-decision', 
          'project-pattern', 'internal-api', 'domain-knowledge', 'implementation-detail', 'project-convention'), 
          metadata.module (affected module or component), metadata.author (who provided this information), 
          metadata.timestamp (ISO date), and metadata.keywords (search terms). DO NOT store generic documentation 
          or examples here - only information specific to this project.",
        "TOOL_FIND_DESCRIPTION": "Search for project-specific context and knowledge before making implementation decisions.
          Use this tool to: 1) Recall project architecture decisions, 2) Follow established project patterns and conventions, 
          3) Find internal API usages specific to this codebase, 4) Understand domain-specific terminology and concepts used 
          in this project. This tool searches project-specific memory only. For official documentation or general examples, 
          use the appropriate specialized memory tools instead. Project context is essential for maintaining consistency 
          with the existing codebase and ensuring new implementations align with established patterns."
      }
    },
    "technical-knowledge": {
      "command": "bash",
      "args": ["-c", "$(pyenv prefix agentic)/bin/python -m uvx mcp-server-qdrant"],
      "env": {
        "QDRANT_URL": "http://qdrant.localhost.loc",
        "COLLECTION_NAME": "technical-knowledge",
        "EMBEDDING_PROVIDER": "lmstudio",
        "EMBEDDING_MODEL": "text-embedding-nomic-embed-text-v1.5-embedding",
        "EMBEDDING_VECTOR_SIZE": "768",
        "LMSTUDIO_API_BASE": "http://localhost:11433/v1",
        "LMSTUDIO_API_KEY": "lm-studio",
        "TOOL_STORE_DESCRIPTION": "Store broader technical CONCEPTS, principles, and best practices.
          This memory is for general software engineering knowledge such as design patterns, architectural principles, 
          performance optimization techniques, security best practices, algorithmic approaches, and system design concepts.
          Include structured metadata: metadata.type ('design-pattern', 'security-practice', 'performance-principle', 
          'architecture-concept', 'algorithm-theory', 'best-practice'), metadata.domain (applicable domain), 
          metadata.source (where the knowledge came from), metadata.timestamp (ISO date), metadata.complexity 
          ('fundamental', 'intermediate', 'advanced'), and metadata.keywords (search terms). Focus on timeless 
          principles rather than specific implementations. Include explanations of WHY certain approaches are 
          recommended, not just HOW to implement them.",
        "TOOL_FIND_DESCRIPTION": "Search for technical concepts, principles, and best practices to inform design decisions.
          Use this tool when you need: 1) Appropriate design patterns for a particular problem, 2) Security best practices 
          for a specific context, 3) Performance optimization principles, 4) Architectural approaches for system design, 
          5) General software engineering best practices. This tool searches technical knowledge memory only. For specific 
          implementations, API details, or project conventions, use the appropriate specialized memory tools instead.
          Technical knowledge provides the foundational understanding needed to make good design decisions and avoid 
          common pitfalls. If relevant knowledge isn't found, use context7 to retrieve established principles and 
          IMMEDIATELY STORE them for future reference."
      }
    }
  }
}

4. Additional MCP Tools

Code Tools

These MCP servers provide code analysis, repository insights, and documentation capabilities:

Context7 MCP Server

Provides intelligent code context and documentation search across multiple sources.

claude mcp add context7 -- npx -y @upstash/context7-mcp@latest

Codacy MCP Server

Integrates code quality analysis and automated code review capabilities.

claude mcp add codacy -- npx -y @codacy/codacy-mcp@latest

Repomix MCP Server

Analyzes and provides insights about repository structure and code patterns.

claude mcp add repomix -- npx -y @repomix/repomix-mcp@latest

Browser Capability Tools

These MCP servers enable web automation and browser interaction:

Playwright MCP Server

Provides browser automation capabilities for web scraping and testing.

claude mcp add playwright -- npx -y @playwright/playwright-mcp@latest

Browser MCP Server

Offers headless browser functionality for web interaction and content extraction.

claude mcp add browser -- npx -y @anthropic/browser-mcp@latest

Integration with Memory System

These tools work synergistically with the vector memory system:

1. Context7 → Store discovered API docs in code-documentation
2. Codacy → Store code quality patterns in technical-knowledge
3. Repomix → Store project insights in project-context
4. Playwright/Browser → Store web scraping examples in code-examples

Example workflow

1. Use Context7 to find documentation Search Context7 for Vue 3 Composition API documentation

2. Store the found documentation Store this Vue 3 Composition API documentation in memory: [Context7 results] Metadata:

   • type: api-reference
   • source: context7
   • framework: vue
   • version: 3.4.0

3. Later retrieve it without external search

Find Vue 3 Composition API documentation

5. Configuration for Other Development Tools

VS Code with Continue

Add to your Continue config (~/.continue/config.json):

{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": "stdio",
        "command": "bash",
        "args": ["-c", "$(pyenv prefix agentic)/bin/python -m uvx mcp-server-qdrant"],
        "env": {
          "QDRANT_URL": "http://qdrant.localhost.loc",
          "COLLECTION_NAME": "code-examples",
          "EMBEDDING_PROVIDER": "lmstudio",
          "EMBEDDING_MODEL": "text-embedding-nomic-embed-text-v1.5-embedding",
          "EMBEDDING_VECTOR_SIZE": "768",
          "LMSTUDIO_API_BASE": "http://localhost:11433/v1",
          "LMSTUDIO_API_KEY": "lm-studio"
        }
      }
    ]
  }
}

Cline (VS Code Extension)

Add to VS Code settings.json: (Use this template for each)

{
  "cline.mcpServers": {
    "qdrant-memory": {
      "command": "bash",
      "args": ["-c", "$(pyenv prefix agentic)/bin/python -m uvx mcp-server-qdrant"],
      "env": {
        "QDRANT_URL": "http://qdrant.localhost.loc",
        "COLLECTION_NAME": "project-context",
        "EMBEDDING_PROVIDER": "lmstudio",
        "EMBEDDING_MODEL": "text-embedding-nomic-embed-text-v1.5-embedding",
        "EMBEDDING_VECTOR_SIZE": "768",
        "LMSTUDIO_API_BASE": "http://localhost:11433/v1",
        "LMSTUDIO_API_KEY": "lm-studio",
        "TOOL_STORE_DESCRIPTION":"Store API documentation,reference materials, and standard usage patterns. This memory store is for OFFICIAL documentation content such as function signatures, parameter details, return types, error codes, and usage requirements. Include structured metadata: metadata.type ('api-reference', 'function-doc', 'class-doc', 'error-docs', 'deprecation-notice'), metadata.language (programming language), metadata.framework (library/framework name), metadata.version (specific version number), metadata.source (e.g., 'context7', 'official-docs'), metadata.timestamp (ISO date), and metadata.keywords (search terms). DO NOT store project-specific code, examples, or general technical concepts here - only official reference material. When storing from context7, mark metadata.source accordingly.",
        "TOOL_FIND_DESCRIPTION":"Search for official API documentation before implementing code. Use this tool to verify exact function signatures, parameter requirements, return types, and accepted values before writing code. Particularly useful for: 1) Checking API details for correct implementation, 2) Confirming deprecation status of methods, 3) Verifying breaking changes between versions, 4) Understanding error states and handling requirements. This tool searches documentation-specific memory only. For implementation examples or project-specific code, use the appropriate specialized memory tools instead. If documentation isn't found, use context7 to retrieve the latest API documentation and IMMEDIATELY STORE it in this memory for future reference."
      }
    }
  }
}

6. How to Use the Memory

Memory Organization

1. Documentation Memory (code-documentation)

   • Store: API references, function signatures, official docs
   • Use: Before implementing features to verify correct API usage

2. Code Examples (code-examples)

   • Store: Working code snippets, implementation patterns
   • Use: When looking for how to implement specific functionality

3. Project Context (project-context)

   • Store: Architecture decisions, project conventions, internal APIs
   • Use: To maintain consistency with existing codebase patterns

4. Technical Knowledge (technical-knowledge)

   • Store: Design patterns, best practices, concepts
   • Use: For architectural decisions and understanding principles

Usage Examples in Claude

Storing documentation with metadata

Store this Vue.js Composition API documentation: Content: [paste Vue.js ref() and reactive() documentation here] Metadata:

• type: api-reference
• language: javascript
• framework: vue
• version: 3.4.0
• source: official-docs
• keywords: composition-api, reactivity, ref, reactive

Finding examples

Find code examples for:

• Error handling patterns for async/await operations
• Language: JavaScript/TypeScript
• Framework: Node.js or Vue.js
• Complexity: intermediate

Storing project context with proper metadata

Store this project convention: Content: We use feature-based folder structure where each feature contains:

• components/ (UI components)
• stores/ (state management)
• tests/ (unit and integration tests)
• api/ (API service calls)
• types/ (TypeScript definitions)

Metadata:

• type: project-convention
• module: folder-structure
• author: team-lead
• keywords: architecture, folder-structure, feature-based

Storing code example with complete metadata

Store this error handling example:

async function fetchUserData(userId: string): Promise<User> {
  try {
    const response = await api.get(`/users/${userId}`);
    return response.data;
  } catch (error) {
    if (error.response?.status === 404) {
      throw new UserNotFoundError(`User ${userId} not found`);
    }
    logger.error('Failed to fetch user', { userId, error });
    throw new ServiceError('Unable to fetch user data');
  }
}

Metadata:

• type: error-handling
• language: typescript
• framework: node
• complexity: intermediate
• source: project-codebase
• keywords: async, error-handling, api-calls, custom-errors

Searching technical knowledge with context

Search for design patterns suitable for:

• Real-time updates in web applications
• Complexity: intermediate to advanced
• Domain: frontend, websockets

Best Practices

1. Be Specific with Metadata: Include type, language, framework, version
2. Use Descriptive Queries: More context helps find better matches
3. Regular Updates: Keep stored information current
4. Cross-Reference: Link related concepts across collections
5. Source Attribution: Always note where information came from

Monitoring and Maintenance

• View stored data: http://qdrant-ui.localhost.loc
• Check collection stats: Use Qdrant UI or API
• Backup data: docker-compose exec qdrant qdrant-backup
• Clear collection: Use Qdrant UI or API endpoints

Troubleshooting

1. Connection Issues

   • Ensure Qdrant is running: docker-compose ps
   • Check LM Studio is running with correct model
   • Verify pyenv environment: pyenv version

2. Embedding Errors

   • Confirm model is loaded in LM Studio
   • Check API endpoint: curl http://localhost:11433/v1/models

3. Search Not Finding Results

   • Verify data exists in collection via UI
   • Try broader search terms
   • Check embedding model consistency