Merge pull request #54 from kc3hack/frontend

Frontend

Author: yudai-kdix

Backend/.dockerignore

@@ -3,6 +3,8 @@ __pycache__
 .venv
 .git
 .gitignore
+.env
+.env.*
 *.pyc
 *.pyo
 *.pyd

Backend/.env.example

@@ -2,8 +2,8 @@
 GEMINI_API_KEY=your_gemini_api_key
 
 # Optional settings (defaults shown)
-GEMINI_MODEL=gemini-1.5-flash
-GEMINI_TIMEOUT_SECONDS=10
+GEMINI_MODEL=gemini-3-flash-preview
+GEMINI_TIMEOUT_SECONDS=30
 GEMINI_PARALLELISM=5
 
 # CockroachDB settings

Backend/Dockerfile

@@ -7,19 +7,12 @@ ENV PYTHONDONTWRITEBYTECODE=1 \
     PIP_NO_CACHE_DIR=1 \
     PIP_PREFER_BINARY=1
 
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends \
-        build-essential \
-        rustc \
-        cargo \
-    && rm -rf /var/lib/apt/lists/*
-
 COPY requirements.txt ./
 RUN pip install --upgrade pip \
     && pip install -r requirements.txt
 
 COPY . .
 
-EXPOSE 8000
+EXPOSE 8080
 
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--reload"]
+CMD ["sh", "-c", "uvicorn main:app --host 0.0.0.0 --port ${PORT:-8080}"]

Backend/README.md

@@ -32,16 +32,35 @@ uvicorn main:app --reload
 ## Docker で起動
 
 ルートディレクトリ（`/Users/honmayuudai/MyHobby/hackson/KC3Hack2026`）で実行してください。
-ARM64 などで `sudachipy` の Linux wheel が無い場合でもビルドできるよう、Dockerfile には Rust ツールチェーンを含めています（初回ビルドは時間がかかる可能性があります）。
+`docker-compose.yml` では `Backend` をデフォルトで `linux/amd64` で起動し、依存の wheel を優先利用します。
+必要に応じて `BACKEND_PLATFORM=linux/arm64` のように上書き可能です。
 
 ```bash
 make up-backend
 ```
 
+初回や Dockerfile 更新後に再ビルドしたい場合:
+
+```bash
+make up-backend-build
+```
+
+Docker の build cache が溜まって容量不足になった場合:
+
+```bash
+make docker-clean
+```
+
 - API ベース URL: `http://localhost:8000`
 - Swagger UI: `http://localhost:8000/docs`
 - ReDoc: `http://localhost:8000/redoc`
 
+## Cloud Run デプロイ
+
+Cloud Run へのデプロイ手順は以下を参照してください。
+
+- `/Users/honmayuudai/MyHobby/hackson/KC3Hack2026/doc/cloud-run-deploy-workflow.md`
+
 ## 現在の API
 
 - `GET /`
@@ -114,7 +133,7 @@ make up-backend
 
 - `POST /dictionary/lookup`
   - 用語の意味を日本語で1〜2文の概要として返す
-  - 現在は単語DB未実装のため、常にGeminiで生成する
+  - このエンドポイントは現在DB参照未連携のため、常にGeminiで生成する
   - `terms` 指定時は、単語ごとに Gemini を非同期並列で呼び出す
   - リクエスト例（単体）:
     ```json
@@ -123,6 +142,22 @@ make up-backend
       "context": "LLMの会話で出てきた用語"
     }
     ```
+
+- `GET /dictionary/entries`
+  - 辞書DBに登録されている単語一覧を取得する
+  - クエリパラメータ: `q`（部分一致）, `limit`, `offset`
+
+- `POST /dictionary/entries/bulk`
+  - カンマ/空白区切りの単語を一括登録する
+  - 各単語について Gemini で説明を生成し、意味ベクトルを付与してDBに保存する
+  - 既存単語はスキップされる
+
+- `PATCH /dictionary/entries/{id}`
+  - 辞書エントリの単語/説明を更新する
+  - 単語変更時は意味ベクトルも再生成する
+
+- `DELETE /dictionary/entries/{id}`
+  - 辞書エントリを削除する
   - リクエスト例（複数）:
     ```json
     {

Backend/app/api/__init__.py

@@ -1,11 +1,11 @@
 import fastapi
-from app.api.endpoints import analysis, dictionary, hoge
+from app.api.endpoints import hoge, analysis, dictionary
 
 router = fastapi.APIRouter()
 
+router.include_router(hoge.router, prefix="/hoge", tags=["hoge"])
 router.include_router(analysis.router, prefix="/analysis", tags=["analysis"])
 router.include_router(dictionary.router, prefix="/dictionary", tags=["dictionary"])
-router.include_router(hoge.router, prefix="/hoge", tags=["hoge"])
 
 # 新しくエンドポイントを追加するときは、
 # 1. app/api/endpoints/new_endpoint.pyを作成する

Backend/app/api/endpoints/dictionary.py

@@ -1,15 +1,67 @@
 from __future__ import annotations
 
+import re
+
 import fastapi
+from sqlalchemy.exc import IntegrityError
 
+from app.core.database import db
+from app.crud.dictionary import (
+    create_dictionary,
+    delete_dictionary,
+    list_dictionaries,
+    read_dictionary_by_id,
+    read_dictionary_by_term,
+    update_dictionary,
+)
 from app.schemas.dictionary import (
+    DictionaryBulkRegisterRequest,
+    DictionaryBulkRegisterResponse,
+    DictionaryBulkRegisterResult,
+    DictionaryBulkRegisterSkipped,
+    DictionaryEntryListResponse,
+    DictionaryEntryResponse,
+    DictionaryEntryUpdateRequest,
     DictionaryLookupBatchResponse,
     DictionaryLookupRequest,
     DictionaryLookupResponse,
 )
 from app.services.dictionary import lookup_term_summary, lookup_terms_summaries
+from app.services.text_analysis import vectorize_pretokenized_words
 
 router = fastapi.APIRouter()
+_TERM_SPLIT_RE = re.compile(r"[,\s、，]+")
+
+
+def _ensure_db_available() -> None:
+    if not db.is_available:
+        raise fastapi.HTTPException(
+            status_code=503,
+            detail="DATABASE_URL is not configured",
+        )
+
+
+def _to_entry_response(entry) -> DictionaryEntryResponse:
+    return DictionaryEntryResponse(
+        id=entry.id,
+        term=entry.term,
+        description=entry.description,
+        meaning_vector=entry.meaning_vector,
+        created_at=entry.created_at,
+        updated_at=entry.updated_at,
+    )
+
+
+def _parse_raw_terms(raw_terms: str) -> list[str]:
+    terms = [term.strip() for term in _TERM_SPLIT_RE.split(raw_terms) if term.strip()]
+    unique_terms = list(dict.fromkeys(terms))
+    for term in unique_terms:
+        if len(term) > 128:
+            raise fastapi.HTTPException(
+                status_code=422,
+                detail="each term must be at most 128 characters",
+            )
+    return unique_terms
 
 
 # 辞書検索API本体。
@@ -37,3 +89,171 @@ def lookup(
     # 単体検索時は従来フォーマットのレスポンスを返す。
     result = lookup_term_summary(term=body.term or "", context=body.context)
     return DictionaryLookupResponse(**result)
+
+
+@router.get(
+    "/entries",
+    response_model=DictionaryEntryListResponse,
+    summary="辞書エントリ一覧を取得する",
+)
+def list_entries(
+    q: str | None = fastapi.Query(default=None, description="用語の部分一致検索"),
+    limit: int = fastapi.Query(default=100, ge=1, le=200),
+    offset: int = fastapi.Query(default=0, ge=0),
+) -> DictionaryEntryListResponse:
+    _ensure_db_available()
+    normalized_q = q.strip() if isinstance(q, str) and q.strip() else None
+    rows, total = list_dictionaries(term_query=normalized_q, limit=limit, offset=offset)
+    return DictionaryEntryListResponse(
+        items=[_to_entry_response(row) for row in rows],
+        total=total,
+        limit=limit,
+        offset=offset,
+    )
+
+
+@router.patch(
+    "/entries/{entry_id}",
+    response_model=DictionaryEntryResponse,
+    summary="辞書エントリを更新する",
+)
+def patch_entry(
+    entry_id: int,
+    body: DictionaryEntryUpdateRequest,
+) -> DictionaryEntryResponse:
+    _ensure_db_available()
+    current = read_dictionary_by_id(entry_id)
+    if current is None:
+        raise fastapi.HTTPException(status_code=404, detail="entry not found")
+
+    meaning_vector: list[float] | None = None
+    if body.term is not None and body.term != current.term:
+        duplicate = read_dictionary_by_term(body.term)
+        if duplicate is not None and duplicate.id != entry_id:
+            raise fastapi.HTTPException(
+                status_code=409,
+                detail="term already exists",
+            )
+        vectors = vectorize_pretokenized_words([(body.term,)])
+        meaning_vector = vectors[0] if vectors else []
+
+    updated = update_dictionary(
+        id=entry_id,
+        term=body.term,
+        description=body.description,
+        meaning_vector=meaning_vector,
+    )
+    if updated is None:
+        raise fastapi.HTTPException(status_code=404, detail="entry not found")
+    return _to_entry_response(updated)
+
+
+@router.delete(
+    "/entries/{entry_id}",
+    status_code=204,
+    summary="辞書エントリを削除する",
+)
+def remove_entry(entry_id: int) -> fastapi.Response:
+    _ensure_db_available()
+    deleted = delete_dictionary(entry_id)
+    if not deleted:
+        raise fastapi.HTTPException(status_code=404, detail="entry not found")
+    return fastapi.Response(status_code=204)
+
+
+@router.post(
+    "/entries/bulk",
+    response_model=DictionaryBulkRegisterResponse,
+    summary="用語を一括登録する",
+    description=(
+        "カンマまたは空白区切りの用語を受け取り、"
+        "Gemini で説明文を生成して辞書DBに登録します。"
+    ),
+)
+def bulk_register(
+    body: DictionaryBulkRegisterRequest,
+) -> DictionaryBulkRegisterResponse:
+    _ensure_db_available()
+    terms = _parse_raw_terms(body.raw_terms)
+    if not terms:
+        raise fastapi.HTTPException(status_code=422, detail="no terms found")
+
+    results: list[DictionaryBulkRegisterResult] = []
+    created_count = 0
+    skipped_count = 0
+
+    for term in terms:
+        existing = read_dictionary_by_term(term)
+        if existing is not None:
+            skipped_count += 1
+            results.append(
+                DictionaryBulkRegisterResult(
+                    term=term,
+                    status="skipped",
+                    skipped=DictionaryBulkRegisterSkipped(
+                        term=term,
+                        reason="already exists",
+                    ),
+                )
+            )
+            continue
+
+        try:
+            llm_result = lookup_term_summary(term=term)
+        except fastapi.HTTPException as exc:
+            skipped_count += 1
+            results.append(
+                DictionaryBulkRegisterResult(
+                    term=term,
+                    status="skipped",
+                    skipped=DictionaryBulkRegisterSkipped(
+                        term=term,
+                        reason=f"lookup failed ({exc.status_code})",
+                    ),
+                )
+            )
+            continue
+
+        vectors = vectorize_pretokenized_words([(term,)])
+        meaning_vector = vectors[0] if vectors else []
+
+        try:
+            entry_id = create_dictionary(
+                term=term,
+                description=llm_result["summary"],
+                meaning_vector=meaning_vector,
+            )
+            created_entry = read_dictionary_by_id(entry_id)
+            if created_entry is None:
+                raise fastapi.HTTPException(
+                    status_code=500,
+                    detail="failed to load created entry",
+                )
+            created_count += 1
+            results.append(
+                DictionaryBulkRegisterResult(
+                    term=term,
+                    status="created",
+                    entry=_to_entry_response(created_entry),
+                )
+            )
+        except IntegrityError:
+            # 並列処理などで同時に同一語が作成された場合はスキップ扱いにする。
+            skipped_count += 1
+            results.append(
+                DictionaryBulkRegisterResult(
+                    term=term,
+                    status="skipped",
+                    skipped=DictionaryBulkRegisterSkipped(
+                        term=term,
+                        reason="already exists",
+                    ),
+                )
+            )
+
+    return DictionaryBulkRegisterResponse(
+        requested_count=len(terms),
+        created_count=created_count,
+        skipped_count=skipped_count,
+        results=results,
+    )