JCcoder0901semantic-search 0.1.0__tar.gz

jccoder0901semantic_search-0.1.0/JCcoder0901semantic_search.egg-info/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: JCcoder0901semantic_search
+Version: 0.1.0
+Summary: Search your own files by meaning, entirely offline, through a simple local web UI.
+Author: Jcthecoder200
+License: MIT
+Project-URL: Homepage, https://github.com/Jcthecoder200/semantic_search
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: fastembed
+Requires-Dist: numpy
+Dynamic: license-file
+
+# Local File Search
+
+Search your own files by *meaning*, not just keyword matching — entirely on
+your own machine, nothing uploaded anywhere.
+
+## Install
+
+**Recommended: [pipx](https://pipx.pypa.io)** — installs the command and
+automatically makes it available in your terminal, avoiding a common
+Windows/Mac/Linux gotcha where plain `pip install` puts the command
+somewhere your terminal doesn't look (see Troubleshooting below if you hit
+this).
+
+```
+pip install pipx
+pipx ensurepath
+pipx install JCcoder0901semantic_search
+```
+*(rename `JCcoder0901semantic_search` once you've picked and published under your
+chosen name)*
+
+**Alternative: plain pip**
+```
+pip install JCcoder0901semantic_search
+```
+
+## Run
+
+```
+localsearch
+```
+
+If that command isn't found, see **Troubleshooting** below — this is a very
+common first-run snag with Python command-line tools in general, not
+specific to this one, and there's a guaranteed-to-work fallback.
+
+Then open your browser to:
+```
+http://127.0.0.1:9120
+```
+
+You'll see a simple page:
+
+1. **Index a folder** — type the full path to a folder you want searchable
+   (e.g. `C:\Users\you\Documents\notes`), pick which extensions to include if
+   you want more than the `.txt`/`.md` defaults, click **Index**.
+
+2. **Search** — pick a mode (file name + content, file name only, or content
+   only), type a plain-English question, click **Search**. Results are
+   ranked by how close their *meaning* is to your question, not exact word
+   matches — a file can show up even without containing your exact search
+   terms.
+
+That's the whole workflow — no curl, no JSON, no terminal commands after the
+initial `localsearch`.
+
+First run downloads a small embedding model (~50MB via `fastembed`), needs
+internet once, then works fully offline.
+
+Your search index is saved to `~/.local_file_search/index.pkl`, so it
+survives restarts — you don't need to re-index folders you already indexed.
+
+## Troubleshooting: "localsearch is not recognized"
+
+This happens when `pip` (not `pipx`) installs the command into a folder your
+terminal's PATH doesn't include — it's a well-known Python packaging quirk,
+most common on Windows, and not something wrong with your installation.
+
+**Guaranteed fix, works every time regardless of PATH:**
+```
+python -m search_api.main
+```
+
+**Permanent fix:** switch to `pipx` (see Install above) — it's built
+specifically to solve this, or manually add Python's Scripts folder to your
+PATH:
+```
+python -c "import sysconfig; print(sysconfig.get_path('scripts'))"
+```
+Add the folder that prints to your system PATH (search "environment
+variables" in the Start menu on Windows), then open a *new* terminal window.
+
+## Running via Docker instead (optional)
+
+If you'd rather not install anything into your system Python, a `Dockerfile`
+is included.
+
+```powershell
+docker build -t local-file-search .
+docker run -p 9120:9120 -v "${PWD}/data:/data" -v "${env:USERPROFILE}:/host" local-file-search
+```
+`${env:USERPROFILE}` mounts your whole Windows user folder as `/host` inside
+the container, so a folder like `Documents\notes` in your profile becomes
+`/host/Documents/notes` when typed into the app. `${PWD}/data:/data`
+persists the index outside the container so it survives restarts.
+
+## Notes on scope
+
+- Only files you explicitly `Index` get searched — nothing is scanned
+  automatically just because it exists on disk.
+- Point Index at specific folders rather than an entire drive — indexing
+  everything would be slow and pull in a lot of irrelevant files.
+- Supported file types by default: `.txt` and `.md`. Add more via the
+  `extensions` field in the Index request, or by editing
+  `search_api/main.py`.
+
+## How it works, briefly
+
+- **Index**: for each matching file, embeds the filename and the content as
+  two *separate* vectors (lists of numbers capturing meaning) using a small
+  local model (via `fastembed`, no PyTorch/GPU required), and saves them to
+  `index.pkl`.
+- **Search**: embeds your question the same way, compares it against the
+  stored vectors by cosine similarity, and returns the closest matches. The
+  mode selector controls whether "closest" is judged by filename, content,
+  or whichever of the two is the stronger match.
+
+## Publishing this yourself (for the maintainer)
+
+```
+pip install build twine
+python -m build
+twine upload dist/*
+```
+Before your first upload: pick a unique name at pypi.org, update it in
+`pyproject.toml` (`name` and the `localsearch` install command above), fill
+in your name in `pyproject.toml` and `LICENSE`, and set up a PyPI API token
+for `twine` to use.

jccoder0901semantic_search-0.1.0/JCcoder0901semantic_search.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+JCcoder0901semantic_search.egg-info/PKG-INFO
+JCcoder0901semantic_search.egg-info/SOURCES.txt
+JCcoder0901semantic_search.egg-info/dependency_links.txt
+JCcoder0901semantic_search.egg-info/entry_points.txt
+JCcoder0901semantic_search.egg-info/requires.txt
+JCcoder0901semantic_search.egg-info/top_level.txt
+search_api/__init__.py
+search_api/main.py
+search_api/static/index.html

jccoder0901semantic_search-0.1.0/JCcoder0901semantic_search.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jccoder0901semantic_search-0.1.0/JCcoder0901semantic_search.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+localsearch = search_api.main:start

jccoder0901semantic_search-0.1.0/JCcoder0901semantic_search.egg-info/requires.txt

@@ -0,0 +1,4 @@
+fastapi
+uvicorn
+fastembed
+numpy

jccoder0901semantic_search-0.1.0/JCcoder0901semantic_search.egg-info/top_level.txt

@@ -0,0 +1 @@
+search_api

jccoder0901semantic_search-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jccoder0901semantic_search-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include search_api/static *

jccoder0901semantic_search-0.1.0/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: JCcoder0901semantic_search
+Version: 0.1.0
+Summary: Search your own files by meaning, entirely offline, through a simple local web UI.
+Author: Jcthecoder200
+License: MIT
+Project-URL: Homepage, https://github.com/Jcthecoder200/semantic_search
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: fastembed
+Requires-Dist: numpy
+Dynamic: license-file
+
+# Local File Search
+
+Search your own files by *meaning*, not just keyword matching — entirely on
+your own machine, nothing uploaded anywhere.
+
+## Install
+
+**Recommended: [pipx](https://pipx.pypa.io)** — installs the command and
+automatically makes it available in your terminal, avoiding a common
+Windows/Mac/Linux gotcha where plain `pip install` puts the command
+somewhere your terminal doesn't look (see Troubleshooting below if you hit
+this).
+
+```
+pip install pipx
+pipx ensurepath
+pipx install JCcoder0901semantic_search
+```
+*(rename `JCcoder0901semantic_search` once you've picked and published under your
+chosen name)*
+
+**Alternative: plain pip**
+```
+pip install JCcoder0901semantic_search
+```
+
+## Run
+
+```
+localsearch
+```
+
+If that command isn't found, see **Troubleshooting** below — this is a very
+common first-run snag with Python command-line tools in general, not
+specific to this one, and there's a guaranteed-to-work fallback.
+
+Then open your browser to:
+```
+http://127.0.0.1:9120
+```
+
+You'll see a simple page:
+
+1. **Index a folder** — type the full path to a folder you want searchable
+   (e.g. `C:\Users\you\Documents\notes`), pick which extensions to include if
+   you want more than the `.txt`/`.md` defaults, click **Index**.
+
+2. **Search** — pick a mode (file name + content, file name only, or content
+   only), type a plain-English question, click **Search**. Results are
+   ranked by how close their *meaning* is to your question, not exact word
+   matches — a file can show up even without containing your exact search
+   terms.
+
+That's the whole workflow — no curl, no JSON, no terminal commands after the
+initial `localsearch`.
+
+First run downloads a small embedding model (~50MB via `fastembed`), needs
+internet once, then works fully offline.
+
+Your search index is saved to `~/.local_file_search/index.pkl`, so it
+survives restarts — you don't need to re-index folders you already indexed.
+
+## Troubleshooting: "localsearch is not recognized"
+
+This happens when `pip` (not `pipx`) installs the command into a folder your
+terminal's PATH doesn't include — it's a well-known Python packaging quirk,
+most common on Windows, and not something wrong with your installation.
+
+**Guaranteed fix, works every time regardless of PATH:**
+```
+python -m search_api.main
+```
+
+**Permanent fix:** switch to `pipx` (see Install above) — it's built
+specifically to solve this, or manually add Python's Scripts folder to your
+PATH:
+```
+python -c "import sysconfig; print(sysconfig.get_path('scripts'))"
+```
+Add the folder that prints to your system PATH (search "environment
+variables" in the Start menu on Windows), then open a *new* terminal window.
+
+## Running via Docker instead (optional)
+
+If you'd rather not install anything into your system Python, a `Dockerfile`
+is included.
+
+```powershell
+docker build -t local-file-search .
+docker run -p 9120:9120 -v "${PWD}/data:/data" -v "${env:USERPROFILE}:/host" local-file-search
+```
+`${env:USERPROFILE}` mounts your whole Windows user folder as `/host` inside
+the container, so a folder like `Documents\notes` in your profile becomes
+`/host/Documents/notes` when typed into the app. `${PWD}/data:/data`
+persists the index outside the container so it survives restarts.
+
+## Notes on scope
+
+- Only files you explicitly `Index` get searched — nothing is scanned
+  automatically just because it exists on disk.
+- Point Index at specific folders rather than an entire drive — indexing
+  everything would be slow and pull in a lot of irrelevant files.
+- Supported file types by default: `.txt` and `.md`. Add more via the
+  `extensions` field in the Index request, or by editing
+  `search_api/main.py`.
+
+## How it works, briefly
+
+- **Index**: for each matching file, embeds the filename and the content as
+  two *separate* vectors (lists of numbers capturing meaning) using a small
+  local model (via `fastembed`, no PyTorch/GPU required), and saves them to
+  `index.pkl`.
+- **Search**: embeds your question the same way, compares it against the
+  stored vectors by cosine similarity, and returns the closest matches. The
+  mode selector controls whether "closest" is judged by filename, content,
+  or whichever of the two is the stronger match.
+
+## Publishing this yourself (for the maintainer)
+
+```
+pip install build twine
+python -m build
+twine upload dist/*
+```
+Before your first upload: pick a unique name at pypi.org, update it in
+`pyproject.toml` (`name` and the `localsearch` install command above), fill
+in your name in `pyproject.toml` and `LICENSE`, and set up a PyPI API token
+for `twine` to use.

jccoder0901semantic_search-0.1.0/README.md

@@ -0,0 +1,128 @@
+# Local File Search
+
+Search your own files by *meaning*, not just keyword matching — entirely on
+your own machine, nothing uploaded anywhere.
+
+## Install
+
+**Recommended: [pipx](https://pipx.pypa.io)** — installs the command and
+automatically makes it available in your terminal, avoiding a common
+Windows/Mac/Linux gotcha where plain `pip install` puts the command
+somewhere your terminal doesn't look (see Troubleshooting below if you hit
+this).
+
+```
+pip install pipx
+pipx ensurepath
+pipx install JCcoder0901semantic_search
+```
+*(rename `JCcoder0901semantic_search` once you've picked and published under your
+chosen name)*
+
+**Alternative: plain pip**
+```
+pip install JCcoder0901semantic_search
+```
+
+## Run
+
+```
+localsearch
+```
+
+If that command isn't found, see **Troubleshooting** below — this is a very
+common first-run snag with Python command-line tools in general, not
+specific to this one, and there's a guaranteed-to-work fallback.
+
+Then open your browser to:
+```
+http://127.0.0.1:9120
+```
+
+You'll see a simple page:
+
+1. **Index a folder** — type the full path to a folder you want searchable
+   (e.g. `C:\Users\you\Documents\notes`), pick which extensions to include if
+   you want more than the `.txt`/`.md` defaults, click **Index**.
+
+2. **Search** — pick a mode (file name + content, file name only, or content
+   only), type a plain-English question, click **Search**. Results are
+   ranked by how close their *meaning* is to your question, not exact word
+   matches — a file can show up even without containing your exact search
+   terms.
+
+That's the whole workflow — no curl, no JSON, no terminal commands after the
+initial `localsearch`.
+
+First run downloads a small embedding model (~50MB via `fastembed`), needs
+internet once, then works fully offline.
+
+Your search index is saved to `~/.local_file_search/index.pkl`, so it
+survives restarts — you don't need to re-index folders you already indexed.
+
+## Troubleshooting: "localsearch is not recognized"
+
+This happens when `pip` (not `pipx`) installs the command into a folder your
+terminal's PATH doesn't include — it's a well-known Python packaging quirk,
+most common on Windows, and not something wrong with your installation.
+
+**Guaranteed fix, works every time regardless of PATH:**
+```
+python -m search_api.main
+```
+
+**Permanent fix:** switch to `pipx` (see Install above) — it's built
+specifically to solve this, or manually add Python's Scripts folder to your
+PATH:
+```
+python -c "import sysconfig; print(sysconfig.get_path('scripts'))"
+```
+Add the folder that prints to your system PATH (search "environment
+variables" in the Start menu on Windows), then open a *new* terminal window.
+
+## Running via Docker instead (optional)
+
+If you'd rather not install anything into your system Python, a `Dockerfile`
+is included.
+
+```powershell
+docker build -t local-file-search .
+docker run -p 9120:9120 -v "${PWD}/data:/data" -v "${env:USERPROFILE}:/host" local-file-search
+```
+`${env:USERPROFILE}` mounts your whole Windows user folder as `/host` inside
+the container, so a folder like `Documents\notes` in your profile becomes
+`/host/Documents/notes` when typed into the app. `${PWD}/data:/data`
+persists the index outside the container so it survives restarts.
+
+## Notes on scope
+
+- Only files you explicitly `Index` get searched — nothing is scanned
+  automatically just because it exists on disk.
+- Point Index at specific folders rather than an entire drive — indexing
+  everything would be slow and pull in a lot of irrelevant files.
+- Supported file types by default: `.txt` and `.md`. Add more via the
+  `extensions` field in the Index request, or by editing
+  `search_api/main.py`.
+
+## How it works, briefly
+
+- **Index**: for each matching file, embeds the filename and the content as
+  two *separate* vectors (lists of numbers capturing meaning) using a small
+  local model (via `fastembed`, no PyTorch/GPU required), and saves them to
+  `index.pkl`.
+- **Search**: embeds your question the same way, compares it against the
+  stored vectors by cosine similarity, and returns the closest matches. The
+  mode selector controls whether "closest" is judged by filename, content,
+  or whichever of the two is the stronger match.
+
+## Publishing this yourself (for the maintainer)
+
+```
+pip install build twine
+python -m build
+twine upload dist/*
+```
+Before your first upload: pick a unique name at pypi.org, update it in
+`pyproject.toml` (`name` and the `localsearch` install command above), fill
+in your name in `pyproject.toml` and `LICENSE`, and set up a PyPI API token
+for `twine` to use.

jccoder0901semantic_search-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+# CHANGE THIS: pick a name not already taken on PyPI (check at pypi.org first).
+name = "JCcoder0901semantic_search"
+version = "0.1.0"
+description = "Search your own files by meaning, entirely offline, through a simple local web UI."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+# CHANGE THIS: put your own name/contact here (or leave email out if you'd rather not share it).
+authors = [
+    { name = "Jcthecoder200" }
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: End Users/Desktop",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+]
+dependencies = [
+    "fastapi",
+    "uvicorn",
+    "fastembed",
+    "numpy",
+]
+
+[project.urls]
+# CHANGE THIS once you have a GitHub repo for it — PyPI shows this on your project page.
+Homepage = "https://github.com/Jcthecoder200/semantic_search"
+
+[project.scripts]
+# This is the command people type after `pip install JCcoder0901semantic_search`.
+localsearch = "search_api.main:start"
+
+[tool.setuptools.packages.find]
+include = ["search_api*"]
+
+[tool.setuptools.package-data]
+# Ships the browser UI (index.html) inside the installed package —
+# without this, pip install would silently omit it and / would 404.
+search_api = ["static/*"]

jccoder0901semantic_search-0.1.0/search_api/main.py

@@ -0,0 +1,239 @@
+import os
+import pickle
+from typing import List
+
+import numpy as np
+import uvicorn
+from fastapi import FastAPI, Query
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from fastembed import TextEmbedding
+from pydantic import BaseModel
+
+app = FastAPI(title="Local File Search")
+
+STATIC_DIR = os.path.join(os.path.dirname(__file__), "static")
+app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+
+
+@app.get("/")
+def home():
+    """Serve the simple browser UI instead of making people use curl/Swagger."""
+    return FileResponse(os.path.join(STATIC_DIR, "index.html"))
+
+# fastembed uses ONNX Runtime instead of PyTorch — much smaller install,
+# no compiled CUDA headers, and critically: no Windows long-path issues
+# during install, which torch is prone to.
+MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
+
+# Default: a hidden folder in the user's home directory, so the index
+# persists regardless of which folder someone runs the command from.
+# Overridable via env var — Docker setups point this at a mounted volume.
+DEFAULT_INDEX_DIR = os.path.join(os.path.expanduser("~"), ".local_file_search")
+INDEX_PATH = os.environ.get("INDEX_PATH", os.path.join(DEFAULT_INDEX_DIR, "index.pkl"))
+
+model = TextEmbedding(model_name=MODEL_NAME)
+
+
+def embed(text: str) -> np.ndarray:
+    """fastembed's .embed() returns a generator — pull the single result out."""
+    return next(model.embed([text]))
+
+
+class IndexRequest(BaseModel):
+    folder_path: str
+    extensions: List[str] = [".txt", ".md"]
+
+
+def load_index() -> dict:
+    """Index format: { file_path: {"snippet": str, "embedding": np.ndarray} }"""
+    if os.path.exists(INDEX_PATH):
+        with open(INDEX_PATH, "rb") as f:
+            return pickle.load(f)
+    return {}
+
+
+def save_index(index: dict) -> None:
+    directory = os.path.dirname(INDEX_PATH)
+    if directory:
+        os.makedirs(directory, exist_ok=True)
+    with open(INDEX_PATH, "wb") as f:
+        pickle.dump(index, f)
+
+
+@app.post("/index")
+def index_folder(req: IndexRequest):
+    """Walk a folder, embed every matching text file, save the index to disk."""
+
+    # Fail loudly instead of silently returning 0 for a bad path.
+    if not os.path.exists(req.folder_path):
+        return {
+            "indexed_files": 0,
+            "error": f"Path does not exist: '{req.folder_path}'. If you're running "
+                     f"this via Docker, remember your real folder needs to be under "
+                     f"the mounted path (e.g. /host/...). If running directly, use "
+                     f"the normal path on your computer.",
+        }
+    if not os.path.isdir(req.folder_path):
+        return {
+            "indexed_files": 0,
+            "error": f"'{req.folder_path}' exists but is not a folder.",
+        }
+
+    index = load_index()
+    indexed = 0
+    scanned = 0
+    empty_count = 0
+    unreadable_count = 0
+    skipped_extensions = set()
+
+    for root, _, files in os.walk(req.folder_path):
+        for fname in files:
+            scanned += 1
+            if not any(fname.endswith(ext) for ext in req.extensions):
+                ext = os.path.splitext(fname)[1] or "(no extension)"
+                skipped_extensions.add(ext)
+                continue
+
+            path = os.path.join(root, fname)
+            try:
+                with open(path, "r", encoding="utf-8", errors="ignore") as f:
+                    text = f.read()
+            except OSError:
+                unreadable_count += 1
+                continue
+
+            if not text.strip():
+                empty_count += 1
+                continue
+
+            # Store filename and content as SEPARATE embeddings, so search can
+            # target either one independently instead of one blended vector.
+            name_without_ext = os.path.splitext(fname)[0].replace("_", " ").replace("-", " ")
+            name_embedding = embed(name_without_ext)
+            content_embedding = embed(text[:2000])
+
+            index[path] = {
+                "snippet": text[:200],
+                "name_embedding": name_embedding,
+                "content_embedding": content_embedding,
+            }
+            indexed += 1
+
+    if indexed == 0 and scanned > 0:
+        reasons = []
+        if skipped_extensions:
+            reasons.append(
+                f"{len(skipped_extensions)} file(s) had a non-matching extension "
+                f"(saw: {sorted(skipped_extensions)}, looking for: {req.extensions})"
+            )
+        if empty_count:
+            reasons.append(f"{empty_count} matching file(s) were empty (no text inside)")
+        if unreadable_count:
+            reasons.append(f"{unreadable_count} matching file(s) couldn't be read")
+        reason_text = "; ".join(reasons) if reasons else "no readable text was found"
+        return {
+            "indexed_files": 0,
+            "total_in_index": len(index),
+            "warning": f"Found {scanned} file(s) in that folder, but indexed none. "
+                       f"Reason: {reason_text}.",
+        }
+    if scanned == 0:
+        return {
+            "indexed_files": 0,
+            "total_in_index": len(index),
+            "warning": f"The folder '{req.folder_path}' exists but contains no files "
+                       f"(checked subfolders too). Double check it's the right path.",
+        }
+
+    save_index(index)
+    return {"indexed_files": indexed, "total_in_index": len(index)}
+
+
+def cosine(a: np.ndarray, b: np.ndarray) -> float:
+    return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b) + 1e-8))
+
+
+@app.get("/search")
+def search(
+    q: str = Query(..., description="Natural language question"),
+    top_k: int = 5,
+    mode: str = Query("both", description="'filename', 'content', or 'both'"),
+):
+    """Embed the query, rank every indexed file by cosine similarity."""
+    index = load_index()
+    if not index:
+        return {"results": [], "message": "Index is empty — call POST /index first."}
+
+    if mode not in ("filename", "content", "both"):
+        return {"results": [], "error": f"Invalid mode '{mode}'. Use 'filename', 'content', or 'both'."}
+
+    # Handle indexes built before the filename/content split existed.
+    stale_entries = [p for p, d in index.items() if "name_embedding" not in d]
+    if stale_entries:
+        return {
+            "results": [],
+            "error": f"{len(stale_entries)} indexed file(s) were indexed with an older "
+                     f"version of this app and need to be re-indexed before search will "
+                     f"work. Click Index again on the same folder(s).",
+        }
+
+    query_embedding = embed(q)
+
+    scored = []
+    for path, data in index.items():
+        name_score = cosine(query_embedding, data["name_embedding"])
+        content_score = cosine(query_embedding, data["content_embedding"])
+
+        if mode == "filename":
+            combined = name_score
+        elif mode == "content":
+            combined = content_score
+        else:  # both — a file counts as relevant if EITHER its name or its content is a strong match
+            combined = max(name_score, content_score)
+
+        scored.append((combined, name_score, content_score, path, data["snippet"]))
+
+    scored.sort(key=lambda x: x[0], reverse=True)
+    top_results = scored[:top_k]
+
+    response = {
+        "results": [
+            {
+                "file": path,
+                "score": round(combined, 4),
+                "name_score": round(name_score, 4),
+                "content_score": round(content_score, 4),
+                "snippet": snippet,
+            }
+            for combined, name_score, content_score, path, snippet in top_results
+        ],
+        "mode": mode,
+    }
+
+    # A real semantic match is typically 0.3+. Below that, results are likely
+    # noise rather than genuinely relevant — flag it instead of implying
+    # confidence the ranking doesn't actually have.
+    if top_results and top_results[0][0] < 0.3:
+        response["note"] = (
+            "Low confidence: none of your indexed files closely match this "
+            "query in meaning. These are just the least-unrelated of what's "
+            "indexed, not strong matches."
+        )
+
+    return response
+
+
+@app.get("/status")
+def status():
+    index = load_index()
+    return {"indexed_files": len(index), "model": MODEL_NAME}
+
+
+def start():
+    print("Starting local semantic search API on http://0.0.0.0:9120 ...")
+    uvicorn.run(app, host="0.0.0.0", port=9120)
+
+
+if __name__ == "__main__":
+    start()

jccoder0901semantic_search-0.1.0/search_api/static/index.html

@@ -0,0 +1,257 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<title>File Search</title>
+<style>
+  :root {
+    --bg: #f6f5f2;
+    --panel: #ffffff;
+    --ink: #1c1c1c;
+    --muted: #6b6b6b;
+    --accent: #2d5c4d;
+    --accent-hover: #234a3e;
+    --border: #e2e0da;
+  }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0;
+    font-family: -apple-system, "Segoe UI", Helvetica, Arial, sans-serif;
+    background: var(--bg);
+    color: var(--ink);
+    display: flex;
+    justify-content: center;
+    padding: 48px 20px;
+  }
+  .app {
+    width: 100%;
+    max-width: 640px;
+  }
+  h1 {
+    font-size: 20px;
+    font-weight: 600;
+    margin: 0 0 4px 0;
+  }
+  .subtitle {
+    color: var(--muted);
+    font-size: 13px;
+    margin-bottom: 28px;
+  }
+  .panel {
+    background: var(--panel);
+    border: 1px solid var(--border);
+    border-radius: 10px;
+    padding: 20px;
+    margin-bottom: 16px;
+  }
+  .panel h2 {
+    font-size: 13px;
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+    color: var(--muted);
+    margin: 0 0 12px 0;
+    font-weight: 600;
+  }
+  .row {
+    display: flex;
+    gap: 8px;
+  }
+  input[type="text"] {
+    flex: 1;
+    padding: 10px 12px;
+    border: 1px solid var(--border);
+    border-radius: 7px;
+    font-size: 14px;
+    background: #fbfaf8;
+  }
+  input[type="text"]:focus {
+    outline: none;
+    border-color: var(--accent);
+  }
+  button {
+    padding: 10px 16px;
+    border: none;
+    border-radius: 7px;
+    background: var(--accent);
+    color: white;
+    font-size: 14px;
+    font-weight: 500;
+    cursor: pointer;
+  }
+  button:hover { background: var(--accent-hover); }
+  button:disabled { background: #b7b7b7; cursor: default; }
+  .status {
+    font-size: 13px;
+    color: var(--muted);
+    margin-top: 10px;
+    min-height: 16px;
+  }
+  .results { margin-top: 8px; }
+  .result {
+    padding: 12px;
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    margin-bottom: 8px;
+    background: #fdfdfc;
+  }
+  .result .path {
+    font-size: 13px;
+    font-weight: 600;
+    word-break: break-all;
+    margin-bottom: 4px;
+  }
+  .result .snippet {
+    font-size: 13px;
+    color: var(--muted);
+    line-height: 1.4;
+  }
+  .result .score {
+    font-size: 11px;
+    color: var(--accent);
+    font-weight: 600;
+    margin-top: 6px;
+  }
+  .hint {
+    font-size: 12px;
+    color: var(--muted);
+    margin-top: 8px;
+  }
+  .mode-row {
+    display: flex;
+    gap: 16px;
+    margin-top: 10px;
+    font-size: 13px;
+    color: var(--muted);
+  }
+  .mode-row label {
+    display: flex;
+    align-items: center;
+    gap: 5px;
+    cursor: pointer;
+  }
+  .mode-row input[type="radio"] {
+    accent-color: var(--accent);
+    cursor: pointer;
+  }
+</style>
+</head>
+<body>
+<div class="app">
+  <h1>File Search</h1>
+  <div class="subtitle">Search your files by meaning, not just keywords. Runs entirely on your machine.</div>
+
+  <div class="panel">
+    <h2>1. Index a folder</h2>
+    <div class="row">
+      <input id="folderInput" type="text" placeholder="C:\Users\you\Documents\notes" />
+      <button id="indexBtn">Index</button>
+    </div>
+    <div class="hint">Type the full path to a folder on your computer. (Running via Docker instead? Prefix with <code>/host/</code>.) Only <code>.txt</code> and <code>.md</code> files are indexed by default.</div>
+    <div class="status" id="indexStatus"></div>
+  </div>
+
+  <div class="panel">
+    <h2>2. Search</h2>
+    <div class="row">
+      <input id="searchInput" type="text" placeholder="e.g. notes about budgeting" />
+      <button id="searchBtn">Search</button>
+    </div>
+    <div class="mode-row">
+      <label><input type="radio" name="searchMode" value="both" checked /> File name + content</label>
+      <label><input type="radio" name="searchMode" value="filename" /> File name only</label>
+      <label><input type="radio" name="searchMode" value="content" /> Content only</label>
+    </div>
+    <div class="status" id="searchStatus"></div>
+    <div class="results" id="results"></div>
+  </div>
+</div>
+
+<script>
+const indexBtn = document.getElementById('indexBtn');
+const searchBtn = document.getElementById('searchBtn');
+const folderInput = document.getElementById('folderInput');
+const searchInput = document.getElementById('searchInput');
+const indexStatus = document.getElementById('indexStatus');
+const searchStatus = document.getElementById('searchStatus');
+const results = document.getElementById('results');
+
+async function indexFolder() {
+  const folder_path = folderInput.value.trim();
+  if (!folder_path) { indexStatus.textContent = 'Enter a folder path first.'; return; }
+  indexBtn.disabled = true;
+  indexStatus.textContent = 'Indexing... this can take a moment for large folders.';
+  try {
+    const res = await fetch('/index', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ folder_path })
+    });
+    const data = await res.json();
+    if (!res.ok) {
+      indexStatus.textContent = 'Error: ' + (data.detail ? JSON.stringify(data.detail) : res.status);
+    } else if (data.error) {
+      indexStatus.textContent = '⚠️ ' + data.error;
+    } else if (data.warning) {
+      indexStatus.textContent = '⚠️ ' + data.warning;
+    } else {
+      indexStatus.textContent = `Indexed ${data.indexed_files} files (${data.total_in_index} total in index).`;
+    }
+  } catch (err) {
+    indexStatus.textContent = 'Request failed: ' + err.message;
+  } finally {
+    indexBtn.disabled = false;
+  }
+}
+
+async function search() {
+  const q = searchInput.value.trim();
+  if (!q) { searchStatus.textContent = 'Type a search first.'; return; }
+  const mode = document.querySelector('input[name="searchMode"]:checked').value;
+  searchBtn.disabled = true;
+  searchStatus.textContent = 'Searching...';
+  results.innerHTML = '';
+  try {
+    const res = await fetch('/search?q=' + encodeURIComponent(q) + '&mode=' + encodeURIComponent(mode));
+    const data = await res.json();
+    if (!res.ok) {
+      searchStatus.textContent = 'Error: ' + (data.detail ? JSON.stringify(data.detail) : res.status);
+      return;
+    }
+    if (data.error) {
+      searchStatus.textContent = '⚠️ ' + data.error;
+      return;
+    }
+    if (!data.results || data.results.length === 0) {
+      searchStatus.textContent = data.message || 'No results.';
+      return;
+    }
+    searchStatus.textContent = `${data.results.length} result(s).` + (data.note ? ' ⚠️ ' + data.note : '');
+    for (const r of data.results) {
+      const div = document.createElement('div');
+      div.className = 'result';
+      div.innerHTML = `
+        <div class="path">${r.file}</div>
+        <div class="snippet">${r.snippet.replace(/</g, '&lt;')}</div>
+        <div class="score">match score: ${r.score} &nbsp;(name: ${r.name_score}, content: ${r.content_score})</div>
+      `;
+      results.appendChild(div);
+    }
+  } catch (err) {
+    searchStatus.textContent = 'Request failed: ' + err.message;
+  } finally {
+    searchBtn.disabled = false;
+  }
+}
+
+folderInput.addEventListener('focus', () => {
+  const len = folderInput.value.length;
+  folderInput.setSelectionRange(len, len);
+});
+
+indexBtn.addEventListener('click', indexFolder);
+searchBtn.addEventListener('click', search);
+folderInput.addEventListener('keydown', e => { if (e.key === 'Enter') indexFolder(); });
+searchInput.addEventListener('keydown', e => { if (e.key === 'Enter') search(); });
+</script>
+</body>
+</html>

jccoder0901semantic_search-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+