@zuvia-software-solutions/code-mapper 2.4.0 → 2.5.0

package/dist/mcp/local/local-backend.js

@@ -57,6 +57,8 @@ export class LocalBackend {
     tsgoServices = new Map();
     /** Per-repo in-memory embedding cache: nodeId → Float32Array (256-dim) */
     embeddingCaches = new Map();
+    /** Per-repo in-memory NL embedding cache: includes source text for match_reason */
+    nlEmbeddingCaches = new Map();
     /** Get (or lazily start) a tsgo LSP service for a repo. Returns null if unavailable. */
     async getTsgo(repo) {
         const existing = this.tsgoServices.get(repo.id);
@@ -140,6 +142,70 @@ export class LocalBackend {
         results.sort((a, b) => a.distance - b.distance);
         return results.slice(0, limit);
     }
+    /** Load NL embeddings into memory for fast conceptual search */
+    loadNlEmbeddingCache(repoId) {
+        try {
+            const db = this.getDb(repoId);
+            let rows;
+            try {
+                rows = db.prepare('SELECT nodeId, embedding, text FROM nl_embeddings').all();
+            }
+            catch {
+                return;
+            } // table might not exist
+            if (rows.length === 0) {
+                this.nlEmbeddingCaches.delete(repoId);
+                return;
+            }
+            const dims = rows[0].embedding.byteLength / 4;
+            const nodeIds = [];
+            const texts = [];
+            const matrix = new Float32Array(rows.length * dims);
+            const norms = new Float32Array(rows.length);
+            for (let i = 0; i < rows.length; i++) {
+                const row = rows[i];
+                nodeIds.push(row.nodeId);
+                texts.push(row.text);
+                const vec = new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4);
+                matrix.set(vec, i * dims);
+                let norm = 0;
+                for (let d = 0; d < dims; d++)
+                    norm += vec[d] * vec[d];
+                norms[i] = Math.sqrt(norm);
+            }
+            this.nlEmbeddingCaches.set(repoId, { nodeIds, texts, matrix, norms });
+        }
+        catch { /* NL embeddings not available */ }
+    }
+    /** Search NL embeddings in memory, returns match_reason text */
+    searchNlEmbeddingsInMemory(repoId, queryVec, limit = 10, maxDistance = 0.5) {
+        const cache = this.nlEmbeddingCaches.get(repoId);
+        if (!cache || cache.nodeIds.length === 0)
+            return [];
+        const dims = queryVec.length;
+        const results = [];
+        let qNorm = 0;
+        for (let d = 0; d < dims; d++)
+            qNorm += queryVec[d] * queryVec[d];
+        qNorm = Math.sqrt(qNorm);
+        if (qNorm === 0)
+            return [];
+        const cacheDims = cache.matrix.length / cache.nodeIds.length;
+        for (let i = 0; i < cache.nodeIds.length; i++) {
+            const offset = i * cacheDims;
+            let dot = 0;
+            const minDims = Math.min(dims, cacheDims);
+            for (let d = 0; d < minDims; d++)
+                dot += queryVec[d] * cache.matrix[offset + d];
+            const similarity = dot / (qNorm * cache.norms[i]);
+            const distance = 1 - similarity;
+            if (distance < maxDistance) {
+                results.push({ nodeId: cache.nodeIds[i], distance, text: cache.texts[i] });
+            }
+        }
+        results.sort((a, b) => a.distance - b.distance);
+        return results.slice(0, limit);
+    }
     /** Hard ceiling — beyond this, incremental is unreliable, warn prominently */
     static MAX_INCREMENTAL_FILES = 200;
     /** Start file system watcher for a repo to detect source changes */
@@ -273,16 +339,17 @@ export class LocalBackend {
         for (const [id, handle] of this.repos) {
             this.startWatcher(id, handle);
             this.seedWatcherFromGit(id, handle);
-            // Load embedding cache into memory for fast vector search
+            // Load embedding caches into memory for fast vector search
             if ((handle.stats?.embeddings ?? 0) > 0) {
                 this.loadEmbeddingCache(id);
                 anyEmbeddings = true;
             }
+            this.loadNlEmbeddingCache(id); // NL cache loaded regardless (cheap, may not exist)
         }
-        // Pre-warm MLX embedder so first query has zero model-load latency
+        // Pre-warm bge-small embedder so first query has zero model-load latency
         if (anyEmbeddings) {
-            import('../../core/embeddings/embedder.js').then(({ initEmbedder }) => {
-                initEmbedder().catch(() => { });
+            import('../../core/embeddings/nl-embedder.js').then(({ initNlEmbedder }) => {
+                initNlEmbedder().catch(() => { });
             }).catch(() => { });
         }
         return this.repos.size > 0;
@@ -592,6 +659,9 @@ export class LocalBackend {
                 const end = d.endLine || 0;
                 const isSmall = end > 0 && start > 0 && (end - start) < 10;
                 lines.push(`  ${sig} — ${d.type} @ ${this.shortPath(d.filePath)}:${start || '?'}${mod}`);
+                if (d.match_reason) {
+                    lines.push(`    _"${d.match_reason}"_`);
+                }
                 if (isSmall && d.content) {
                     const src = String(d.content).trim();
                     if (src.length < 500) {
@@ -671,6 +741,9 @@ export class LocalBackend {
                 renderFlows(2);
             }
         }
+        lines.push('');
+        lines.push('---');
+        lines.push('_Note: Results ranked by BM25 keyword + semantic + refs + file-content signals. Natural language queries may miss code using different terminology. If results seem incomplete, try specific identifiers or `grep -rn "keyword" --include="*.ts"` for exhaustive search._');
         return lines.join('\n');
     }
     formatContextAsText(result) {
@@ -776,6 +849,10 @@ export class LocalBackend {
                 lines.push(`  ${p.name} (step ${p.step_index}/${p.step_count})`);
             }
         }
+        // Guidance footer for agents
+        lines.push('');
+        lines.push('---');
+        lines.push('_Note: Callers are from graph edges + refs index. For widely-used symbols, verify completeness with `grep -rn "symbolName(" --include="*.ts"`. Outgoing calls may miss dynamic dispatch or reflection._');
         return lines.join('\n');
     }
     formatImpactAsText(result) {
@@ -822,6 +899,9 @@ export class LocalBackend {
             lines.push('');
             lines.push(`### Modules: ${mods.map((m) => `${m.name} (${m.hits} ${m.impact})`).join(' | ')}`);
         }
+        lines.push('');
+        lines.push('---');
+        lines.push('_Note: d=1 callers include graph edges + refs index. Indirect deps through dynamic dispatch, config, or type-only references may not appear. For critical changes, verify d=1 with `grep -rn "symbolName" --include="*.ts"`._');
         return lines.join('\n');
     }
     formatDetectChangesAsText(result) {
@@ -1002,13 +1082,14 @@ export class LocalBackend {
         // Step 1: Four-signal search in parallel
         // BM25 uses expanded query; semantic uses enriched query; refs + file_words use raw query
         const searchLimit = processLimit * maxSymbolsPerProcess;
-        const [bm25Results, semanticResults, refsResults, fileWordsResults] = await Promise.all([
+        const [bm25Results, semanticResults, nlSemanticResults, refsResults, fileWordsResults] = await Promise.all([
             this.bm25Search(repo, expandedSearchQuery, searchLimit),
             this.semanticSearch(repo, semanticQuery, searchLimit),
+            this.nlSemanticSearch(repo, searchQuery, searchLimit),
             Promise.resolve(this.refsSearch(repo, searchQuery, searchLimit)),
             Promise.resolve(this.fileWordsSearch(repo, searchQuery, searchLimit)),
         ]);
-        // Step 2: Weighted RRF merge (4 signals)
+        // Step 2: Weighted RRF merge (5 signals)
         const bm25ForRRF = bm25Results.map((r, i) => ({
             nodeId: String(r.nodeId ?? ''),
             name: String(r.name ?? ''),
@@ -1039,6 +1120,34 @@ export class LocalBackend {
             ...(r.endLine != null ? { endLine: r.endLine } : {}),
         }));
         let rrfMerged = mergeWithRRF(bm25ForRRF, semanticForRRF, { limit: searchLimit });
+        // Store NL match reasons for display
+        const nlMatchReasons = new Map();
+        for (const r of nlSemanticResults) {
+            if (r.match_reason && !nlMatchReasons.has(r.nodeId)) {
+                nlMatchReasons.set(r.nodeId, r.match_reason);
+            }
+        }
+        // Inject NL semantic results directly — they bridge the vocabulary gap
+        // that BM25 and code embeddings miss. Insert at high score so they
+        // appear in results even when BM25 finds unrelated "prevent" matches.
+        if (nlSemanticResults.length > 0) {
+            const mainIds = new Set(rrfMerged.map(r => r.nodeId || r.filePath));
+            const topMainScore = rrfMerged[0]?.score ?? 0.01;
+            for (let i = 0; i < Math.min(nlSemanticResults.length, 5); i++) {
+                const nlr = nlSemanticResults[i];
+                if (mainIds.has(nlr.nodeId))
+                    continue; // already in results
+                // Score NL results high — at or above the top BM25 result
+                const nlScore = topMainScore * (1.0 - i * 0.1);
+                rrfMerged.push({
+                    filePath: nlr.filePath, score: nlScore, rank: i + 1,
+                    sources: ['semantic'], nodeId: nlr.nodeId, name: nlr.name,
+                    label: nlr.type, startLine: nlr.startLine, endLine: nlr.endLine,
+                });
+            }
+            rrfMerged.sort((a, b) => b.score - a.score);
+            rrfMerged = rrfMerged.slice(0, searchLimit);
+        }
         // Merge refs + fileWords into the RRF results (lower weight)
         if (refsForRRF.length > 0 || fileWordsForRRF.length > 0) {
             const supplemental = mergeWithRRF(refsForRRF, fileWordsForRRF.map((r) => ({
@@ -1084,21 +1193,29 @@ export class LocalBackend {
             if (!searchDataMap.has(key))
                 searchDataMap.set(key, r);
         }
-        let merged = rrfMerged.map(rrf => ({
-            score: rrf.score,
-            data: searchDataMap.get(rrf.nodeId ?? '') ?? searchDataMap.get(rrf.filePath) ?? {
+        for (const r of nlSemanticResults) {
+            const key = r.nodeId || r.filePath;
+            if (!searchDataMap.has(key))
+                searchDataMap.set(key, r);
+        }
+        let merged = rrfMerged.map(rrf => {
+            const data = searchDataMap.get(rrf.nodeId ?? '') ?? searchDataMap.get(rrf.filePath) ?? {
                 name: rrf.name ?? rrf.filePath.split('/').pop(), type: rrf.label ?? 'File',
                 filePath: rrf.filePath, nodeId: rrf.nodeId,
-            },
-        }));
-        // Filter noise: remove test files, config files, docs from results by default
+            };
+            // Attach NL match reason if available
+            const reason = nlMatchReasons.get(rrf.nodeId ?? '') ?? nlMatchReasons.get(data.nodeId ?? '');
+            if (reason)
+                data.match_reason = reason;
+            return { score: rrf.score, data };
+        });
+        // Filter non-code files (JSON, MD, YAML). Test files are included by default.
+        // Agents can pass exclude_tests: true to filter test files when not needed.
         merged = merged.filter(item => {
             const fp = String(item.data.filePath ?? '').toLowerCase();
-            if (isTestFilePath(fp))
-                return false;
             if (fp.endsWith('.json') || fp.endsWith('.md') || fp.endsWith('.yml') || fp.endsWith('.yaml'))
                 return false;
-            if (fp.includes('/skills/') || fp.includes('/fixtures/') || fp.includes('/eval/'))
+            if (params.exclude_tests && isTestFilePath(fp))
                 return false;
             return true;
         });
@@ -1482,8 +1599,8 @@ export class LocalBackend {
                     return [];
             }
             const { DEFAULT_MAX_SEMANTIC_DISTANCE } = await import('../../core/search/types.js');
-            const { embedQuery } = await import('../../core/embeddings/embedder.js');
-            const queryVec = await embedQuery(query);
+            const { nlEmbed } = await import('../../core/embeddings/nl-embedder.js');
+            const queryVec = await nlEmbed(query);
             // In-memory cosine search — no disk I/O
             const vecResults = this.searchEmbeddingsInMemory(repo.id, queryVec, limit, DEFAULT_MAX_SEMANTIC_DISTANCE);
             if (vecResults.length === 0)
@@ -1511,6 +1628,53 @@ export class LocalBackend {
             return [];
         }
     }
+    /**
+     * NL semantic search: embed query with bge-small, search NL descriptions.
+     * Returns match_reason (the NL text that matched) for agent transparency.
+     */
+    async nlSemanticSearch(repo, query, limit) {
+        try {
+            let cache = this.nlEmbeddingCaches.get(repo.id);
+            if (!cache || cache.nodeIds.length === 0) {
+                // Try loading on demand
+                this.loadNlEmbeddingCache(repo.id);
+                cache = this.nlEmbeddingCaches.get(repo.id);
+                if (!cache || cache.nodeIds.length === 0)
+                    return [];
+            }
+            const { nlEmbed } = await import('../../core/embeddings/nl-embedder.js');
+            const queryVec = await nlEmbed(query);
+            const vecResults = this.searchNlEmbeddingsInMemory(repo.id, queryVec, limit, 0.5);
+            if (vecResults.length === 0)
+                return [];
+            // Fetch node metadata
+            const metaDb = this.getDb(repo.id);
+            const seen = new Set();
+            const results = [];
+            for (const r of vecResults) {
+                if (seen.has(r.nodeId))
+                    continue;
+                seen.add(r.nodeId);
+                const node = getNode(metaDb, toNodeId(r.nodeId));
+                if (node) {
+                    results.push({
+                        nodeId: r.nodeId,
+                        name: node.name,
+                        type: node.label,
+                        filePath: node.filePath,
+                        distance: r.distance,
+                        startLine: node.startLine,
+                        endLine: node.endLine,
+                        match_reason: r.text, // The NL text that matched — shown to agents
+                    });
+                }
+            }
+            return results;
+        }
+        catch {
+            return [];
+        }
+    }
     /**
      * Refs-based search: find symbols referenced in files that contain the query identifiers.
      * Bridges the gap between graph edges (incomplete) and grep (complete for exact names).
@@ -1597,8 +1761,8 @@ export class LocalBackend {
             const cache = this.embeddingCaches.get(repo.id);
             if (!cache || cache.nodeIds.length === 0)
                 return [];
-            const { embedQuery } = await import('../../core/embeddings/embedder.js');
-            const queryVec = await embedQuery(query);
+            const { nlEmbed } = await import('../../core/embeddings/nl-embedder.js');
+            const queryVec = await nlEmbed(query);
             const neighbors = this.searchEmbeddingsInMemory(repo.id, queryVec, 5, 0.7);
             // Extract symbol names from nodeIds (format: "Label:filePath:name")
             return neighbors.map(n => {
@@ -2033,24 +2197,30 @@ export class LocalBackend {
         }
         // Supplement callers from refs table (catches callers the graph missed)
         try {
-            const refCallers = findRefsBySymbol(db, sym.name, 100);
+            const refCallers = findRefsBySymbol(db, sym.name, 200);
             const knownFiles = new Set(incomingRows.map(r => r.filePath));
+            let refsAdded = 0;
             for (const ref of refCallers) {
                 if (ref.filePath === sym.filePath)
                     continue; // skip self-file
                 if (knownFiles.has(ref.filePath))
-                    continue; // already known
-                knownFiles.add(ref.filePath);
+                    continue; // already have a caller from this file
                 const enclosing = this.findNodeAtPosition(db, ref.filePath, ref.line);
-                if (enclosing) {
-                    incomingRows.push({
-                        relType: 'CALLS', uid: '', name: enclosing.name, filePath: ref.filePath,
-                        kind: enclosing.label, startLine: ref.line, reason: 'refs-index',
-                    });
-                }
+                if (!enclosing)
+                    continue; // no symbol at this line (e.g. import statement)
+                knownFiles.add(ref.filePath); // mark AFTER finding a valid node
+                incomingRows.push({
+                    relType: 'CALLS', uid: '', name: enclosing.name, filePath: ref.filePath,
+                    kind: enclosing.label, startLine: ref.line, reason: 'refs-index',
+                });
+                refsAdded++;
             }
+            if (process.env['CODE_MAPPER_VERBOSE'])
+                console.error(`Code Mapper: refs supplement for '${sym.name}': ${refsAdded} added from ${refCallers.length} refs`);
+        }
+        catch (err) {
+            console.error(`Code Mapper: refs supplement failed: ${err instanceof Error ? err.message : err}`);
         }
-        catch { /* refs table may not exist yet */ }
         // Outgoing refs — exclude generic method names that produce false positives at low confidence
         const GENERIC_NAMES_EXCLUDE = new Set(['has', 'get', 'set', 'add', 'remove', 'delete', 'close', 'stop', 'clear', 'reset', 'toString', 'valueOf', 'push', 'pop', 'entries', 'keys', 'values']);
         let outgoingRows = [];
@@ -2388,10 +2558,44 @@ export class LocalBackend {
                 logQueryError('rename:read-ref', e);
             }
         }
-        // Step 3: Text search for refs the graph might have missed
-        let astSearchEdits = 0;
+        // Step 3a: Refs table lookup (instant, covers most cases the graph missed)
+        let refsEdits = 0;
         const graphFiles = new Set([sym.filePath, ...allIncoming.map(r => r.filePath)].filter(Boolean));
-        // Simple text search across the repo for the old name (in files not already covered by graph)
+        try {
+            const refsDb = this.getDb(repo.id);
+            const refsForName = findRefsBySymbol(refsDb, oldName, 500);
+            for (const ref of refsForName) {
+                const normalizedFile = ref.filePath.replace(/\\/g, '/');
+                if (graphFiles.has(normalizedFile))
+                    continue;
+                graphFiles.add(normalizedFile); // mark so ripgrep doesn't re-process
+                try {
+                    const content = await fs.readFile(assertSafePath(normalizedFile), 'utf-8');
+                    const lines = content.split('\n');
+                    const regex = new RegExp(`\\b${oldName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'g');
+                    for (let i = 0; i < lines.length; i++) {
+                        const searchLine = lines[i];
+                        if (!searchLine)
+                            continue;
+                        regex.lastIndex = 0;
+                        if (regex.test(searchLine)) {
+                            regex.lastIndex = 0;
+                            addEdit(normalizedFile, i + 1, searchLine.trim(), searchLine.replace(regex, new_name).trim(), 'refs');
+                            refsEdits++;
+                        }
+                    }
+                }
+                catch (e) {
+                    logQueryError('rename:refs-read', e);
+                }
+            }
+        }
+        catch (e) {
+            logQueryError('rename:refs', e);
+        }
+        // Step 3b: Ripgrep text search for anything refs + graph missed
+        let astSearchEdits = 0;
+        // Simple text search across the repo for the old name (in files not already covered)
         try {
             const { execFileSync } = await import('child_process');
             const rgArgs = [
@@ -2456,9 +2660,11 @@ export class LocalBackend {
             files_affected: allChanges.length,
             total_edits: totalEdits,
             graph_edits: graphEdits,
+            refs_edits: refsEdits,
             text_search_edits: astSearchEdits,
             changes: allChanges,
             applied: !dry_run,
+            _note: 'Rename uses graph edges + refs index + ripgrep. Always review changes before applying. String literals, comments, and dynamic references (e.g. obj[methodName]) need manual review.',
         };
     }
     async impact(repo, params) {
@@ -2535,6 +2741,32 @@ export class LocalBackend {
                 }
             }
         }
+        // Supplement d=1 callers from refs table (catches callers the graph missed)
+        if (direction === 'upstream') {
+            try {
+                const targetName = sym.name;
+                const d1FromRefs = findRefsBySymbol(db, targetName, 200);
+                for (const ref of d1FromRefs) {
+                    if (ref.filePath === sym.filePath)
+                        continue;
+                    const refNode = this.findNodeAtPosition(db, ref.filePath, ref.line);
+                    if (refNode && !seenIds.has(refNode.name + ':' + ref.filePath)) {
+                        // Find the actual node ID for this position
+                        const fullNodes = findNodesByFile(db, ref.filePath);
+                        const match = fullNodes.find(n => n.name === refNode.name && n.startLine != null && n.startLine <= ref.line + 1 && (n.endLine ?? 9999) >= ref.line + 1);
+                        if (match && !seenIds.has(match.id) && !startIds.some(s => s === match.id)) {
+                            seenIds.add(match.id);
+                            mergedNodes.push({
+                                id: match.id, name: match.name, label: match.label,
+                                filePath: match.filePath, depth: 1,
+                                relationType: 'CALLS', confidence: 0.8,
+                            });
+                        }
+                    }
+                }
+            }
+            catch { /* refs table may not exist */ }
+        }
         const impacted = mergedNodes;
         const truncated = anyTruncated;
         const grouped = {};

package/dist/mcp/server.js

@@ -13,8 +13,8 @@ import { getResourceDefinitions, getResourceTemplates, readResource } from './re
 // the MCP tool descriptions. Hints wasted ~40 tokens per response.
 /** Create a configured MCP Server with all handlers registered (transport-agnostic) */
 export function createMCPServer(backend) {
-    // Preload embedding model in background so first query doesn't pay cold-start cost
-    import('../core/embeddings/embedder.js').then(m => m.initEmbedder()).catch(() => { });
+    // Preload bge-small embedding model in background so first query doesn't pay cold-start cost
+    import('../core/embeddings/nl-embedder.js').then(m => m.initNlEmbedder()).catch(() => { });
     const require = createRequire(import.meta.url);
     const pkgVersion = require('../../package.json').version;
     const server = new Server({

package/dist/mcp/tools.js

@@ -44,6 +44,7 @@ Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank
                 limit: { type: 'number', description: 'Max processes to return (default: 5)', default: 5 },
                 max_symbols: { type: 'number', description: 'Max symbols per process (default: 10)', default: 10 },
                 include_content: { type: 'boolean', description: 'Include full symbol source code (default: false)', default: false },
+                exclude_tests: { type: 'boolean', description: 'Exclude test/spec/fixture files from results (default: false)', default: false },
                 repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
             },
             required: ['query'],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zuvia-software-solutions/code-mapper",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",
@@ -34,10 +34,7 @@
     "hooks",
     "scripts",
     "skills",
-    "vendor",
-    "models/mlx-embedder.py",
-    "models/jina-code-0.5b-mlx/model.py",
-    "models/jina-code-0.5b-mlx/config.json"
+    "vendor"
   ],
   "scripts": {
     "build": "tsc",

package/models/jina-code-0.5b-mlx/config.json

@@ -1,73 +0,0 @@
-{
-  "architectures": [
-    "Qwen2ForCausalLM"
-  ],
-  "attention_dropout": 0.0,
-  "bos_token_id": 151643,
-  "eos_token_id": 151643,
-  "hidden_act": "silu",
-  "hidden_size": 896,
-  "initializer_range": 0.02,
-  "intermediate_size": 4864,
-  "layer_types": [
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention",
-    "full_attention"
-  ],
-  "matryoshka_dims": [
-    64,
-    128,
-    256,
-    512,
-    896
-  ],
-  "max_position_embeddings": 32768,
-  "max_window_layers": 24,
-  "model_type": "qwen2",
-  "num_attention_heads": 14,
-  "num_hidden_layers": 24,
-  "num_key_value_heads": 2,
-  "prompt_names": [
-    "query",
-    "passage"
-  ],
-  "rms_norm_eps": 1e-06,
-  "rope_scaling": null,
-  "rope_theta": 1000000.0,
-  "sliding_window": null,
-  "task_names": [
-    "nl2code",
-    "qa",
-    "code2code",
-    "code2nl",
-    "code2completion"
-  ],
-  "tie_word_embeddings": true,
-  "tokenizer_class": "Qwen2TokenizerFast",
-  "torch_dtype": "bfloat16",
-  "transformers_version": "4.53.0",
-  "use_cache": true,
-  "use_sliding_window": false,
-  "vocab_size": 151936
-}