with st.spinner("PDFを読み込み中"):
    extract_text = extract_text_from_pdf(uploaded_file)

st.session_state.pdf_text = extract_text

# ⭕ 意図：再実行で状態が消えないようPDFテキストをセッション保持
# ⚠️ 問題：通常変数だとボタン押下で毎回リセットされる
# ✅ 解決：セッション変数 st.session_state を使用

extract_text[:500] + "..."

with st.expander("📖 テキストプレビュー"):
    st.text_area(...)

import tiktoken
encoding = tiktoken.encoding_for_model("gpt-4o-mini")
num_tokens = len(encoding.encode("これはテストです。"))

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    length_function=len,  # ← ここが「文字数ベース」
)

length_function=lambda x: len(tiktoken.encoding_for_model("gpt-4o").encode(x))

1. ドキュメントを読み込む
2. 意味のまとまり（チャンク）単位に分割
3. 各チャンクをベクトル化（埋め込みモデル使用）
4. ベクトル＋メタデータをベクトルストアに保存（例：ChromaDB）

5. ユーザーが自然言語で質問
6. 質問をベクトル化（埋め込みモデル）
7. ベクトルストアから意味的に近いチャンクを検索
8. 検索結果＋質問をプロンプトにしてLLMに渡す
9. LLMが文脈を考慮して回答を生成

attempt to write a readonly database

def create_vector_store(text_chunks, embeddings, persist_directory="./vectorstore"):
    # 既存フォルダを無条件で削除 → ロック中のDBファイルが残る
    if os.path.exists(persist_directory):
        shutil.rmtree(persist_directory)

    vs = Chroma.from_texts(
        texts=text_chunks,
        embedding=embeddings,
        persist_directory=persist_directory
    )
    vs.persist()
    return vs

-from langchain.vectorstores import Chroma
+from chromadb.config import Settings
+from langchain_community.vectorstores import Chroma

 CHROMA_SETTINGS = Settings(
     allow_reset=True,           # ← 開発用リセット機能を許可
     is_persistent=True,
     persist_directory=str(PERSIST_DIR),
     anonymized_telemetry=False,
 )

 def rebuild_vectorstore(chunks, embeds):
-    # 丸ごと削除してから生成 → readonly error
-    if os.path.exists(str(PERSIST_DIR)):
-        shutil.rmtree(str(PERSIST_DIR))
+    # ① 既存インスタンスを pop して取り出し
+    vs_old = st.session_state.pop("vectorstore", None)
+    if vs_old:
+        # ② クライアント内部リセットで DB をクリーンに初期化
+        vs_old._client.reset()
+        # ③ Python/C側リソースを解放
+        del vs_old
+        gc.collect()

+    # ④ 新コレクションを client_settings 経由で生成
     vs_new = Chroma.from_texts(
         texts=chunks,
         embedding=embeds,
-        persist_directory=str(PERSIST_DIR)
+        client_settings=CHROMA_SETTINGS
     )
     vs_new.persist()
     st.session_state.vectorstore = vs_new

+    # ⑤ 不要フォルダを個別に削除
     current_uuid = vs_new._collection.id
     cleanup_dirs(current_uuid)

     return vs_new

def cleanup_dirs(keep_uuid: str | None):
    if not PERSIST_DIR.exists():
        return
    for p in PERSIST_DIR.iterdir():
        # 現行コレクション以外を物理削除
        if p.is_dir() and p.name != keep_uuid:
            shutil.rmtree(p)

current_uuid = vs_new._collection.id

from langchain_community.vectorstores import Chroma

vs_new = Chroma.from_texts(
    texts=chunks,
    embedding=embeds,
    client_settings=CHROMA_SETTINGS,
)

>>> type(vs_new._collection)
<class 'chromadb.db.local.LocalCollection'>

# コレクションの登録ディレクトリ確認
collection = vs_new._collection
print("コレクションID:", collection.id)
# → vectorstore/<collection.id>/ 以下に SQLite/Parquet が保存される

# 類似検索はラッパー経由で実行
results = vs_new.similarity_search_with_score("検索クエリ", k=5)

vs_new = Chroma.from_texts(
    texts=chunks,            # 👉 チャンク化したテキストリスト
    embedding=embeds,         # 👉 OpenAIEmbeddings インスタンス
    client_settings=CHROMA_SETTING  # 👉 永続化設定付き Settings オブジェクト
)
vs_new.persist()

vs = Chroma(
    persist_directory=str(PERSIST_DIR),  # 👉 永続化ディレクトリ
    embedding_function=embeds,           # 👉 埋め込み生成を行うコールバック
    client_settings=CHROMA_SETTING       # 👉 永続化設定付き Settings オブジェクト
)

@st.cache_data
def extract_text_from_pdf(pdf_file: Union[str, bytes]) -> str:
    reader = PyPDF2.PdfReader(pdf_file)
    texts = (page.extract_text() or "" for page in reader.pages)
    return "\n".join(texts)

from langchain.text_splitter import RecursiveCharacterTextSplitter

def split_text(text: str, size=1000, overlap=200):
    splitter = RecursiveCharacterTextSplitter(
        chunk_size=size,                           # チャンクの最大サイズ
        chunk_overlap=overlap,                     # 重複させる文字数
        separators=["\n\n", "\n", " ", ""],       # 分割に使用する区切り文字
        length_function=len,                       # 長さの測定方法
    )
    return splitter.split_text(text)

separators = ["\n\n", "\n", " ", ""]

元テキスト:
段落1の内容が続きます...（1500文字）

段落2の内容です。（300文字）

段落3の内容が続きます...（1200文字）

段落1 → 改行で分割 → 800文字 + 700文字 → ✅ 両方OK
段落3 → 改行で分割 → 600文字 + 600文字 → ✅ 両方OK

chunk_size = 1000
chunk_overlap = 200

チャンク1: 文字位置    0 ～ 1000 （1000文字）
チャンク2: 文字位置  800 ～ 1800 （1000文字）← 200文字重複
チャンク3: 文字位置 1600 ～ 2600 （1000文字）← 200文字重複
チャンク4: 文字位置 2400 ～ 3000 （600文字）

# 目標の重複：200文字
# 実際の重複：separatorsによって調整される

# 例：段落境界で調整
チャンク1の末尾: "...クラス名の命名規則について"
チャンク2の先頭: "クラス名の命名規則について詳しく説明します..."
# → 実際の重複：180文字（段落境界を優先）

length_function=len,  # 文字数で測定

import tiktoken

def count_tokens(text: str, model="gpt-4o-mini"):
    enc = tiktoken.encoding_for_model(model)
    return len(enc.encode(text))

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,  # 1000トークン
    chunk_overlap=200,
    separators=["\n\n", "\n", " ", ""],
    length_function=lambda x: count_tokens(x, "gpt-4o-mini"),  # トークン数で測定
)

def create_japanese_splitter(chunk_size=1000, overlap=200):
    return RecursiveCharacterTextSplitter(
        chunk_size=chunk_size,
        chunk_overlap=overlap,
        separators=[
            "\n\n",  # 段落区切り（最優先）
            "\n",    # 改行
            "。",    # 日本語の句点
            "！",    # 感嘆符
            "？",    # 疑問符
            " ",     # 空白
            "",      # 文字単位（最後の手段）
        ],
        length_function=len,
    )

from langchain.text_splitter import Language

# Python用の設定
python_splitter = RecursiveCharacterTextSplitter.from_language(
    language=Language.PYTHON,
    chunk_size=1000,
    chunk_overlap=200
)

# 用途別推奨値
document_qa = 1000    # 文書QA：詳細な情報が必要
summary = 2000        # 要約：長めの文脈が必要  
code_search = 500     # コード検索：関数単位での分割

# chunk_sizeの10-20%が目安
chunk_size = 1000
chunk_overlap = chunk_size * 0.2  # 200文字（20%）

# 文書の種類による調整
technical_doc = chunk_size * 0.1   # 技術文書：重複少なめ
narrative_text = chunk_size * 0.3  # 物語：文脈重視で重複多め

import streamlit as st
from langchain_community.vectorstores import Chroma

def process_pdf_for_rag(pdf_text: str):
    # 最適化されたスプリッター
    splitter = RecursiveCharacterTextSplitter(
        chunk_size=1000,
        chunk_overlap=200,
        separators=["\n\n", "\n", "。", " ", ""],
        length_function=len,
    )
    
    # チャンクに分割
    chunks = splitter.split_text(pdf_text)
    
    # ベクトルストアに保存
    vectorstore = Chroma.from_texts(
        texts=chunks,
        embedding=embeddings,
    )
    
    return vectorstore, chunks

# 分割結果の確認
st.write(f"📊 分割統計:")
st.write(f"- 元文書: {len(pdf_text):,}文字")
st.write(f"- チャンク数: {len(chunks)}")
st.write(f"- 平均チャンクサイズ: {sum(len(c) for c in chunks) // len(chunks)}文字")

# 問題：チャンクサイズのばらつきが大きい
# 対処：separatorsを文書の構造に合わせて調整

# Markdown文書の場合
markdown_separators = [
    "\n## ",   # 見出し2
    "\n### ",  # 見出し3
    "\n\n",    # 段落
    "\n",      # 改行
    " ",       # 空白
    "",        # 文字
]

# 問題：overlapが期待値と大きく異なる
# 対処：separatorの優先順位を見直す

# 厳密な重複が必要な場合
strict_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separators=[" ", ""],  # 空白と文字のみ（構造を無視）
    length_function=len,
)

fetch('/api/file/delete', { method: 'DELETE', body: 'foo.txt' });

fetch('/api/file/delete', {
  method: 'DELETE',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ fileName: 'foo.txt' }),
});

export async function DELETE(req: Request) {
  const copy = req.clone();
  const raw = await copy.text();
  const data = await req.json().catch(() => null);
}

const reader = req.body?.getReader();
const chunks: Uint8Array[] = [];
while (reader) {
  const { value, done } = await reader.read();
  if (done) break;
  if (value) chunks.push(value);
}
const text = new TextDecoder().decode(
  Uint8Array.from(chunks.flat())
);

const text = await new Response(req.body).text();

// app/api/file/delete/route.ts
import { NextResponse } from 'next/server';

export async function DELETE(req: Request) {
  const fileName = await req.text();
  console.log('[DELETE /api/file/delete] fileName =', fileName);
  return NextResponse.json({ ok: true, fileName });
}

// app/api/any/route.ts
const API_BASE = process.env.NEXT_PUBLIC_API_BASE ?? 'http://localhost:8000'
const API_PATH = process.env.NEXT_PUBLIC_API_BASE_PATH ?? '/api/v1'

async function handleResponse(res: Response) {
  if (res.ok) return res.json()
  let detail = 'Unknown error'
  try { detail = (await res.json()).detail || detail } catch {}
  throw new Error(detail)
}

export async function GET() {
  const ac = new AbortController()
  const t = setTimeout(() => ac.abort(), 10000)
  try {
    const r = await fetch(`${API_BASE}${API_PATH}/resource`, {
      method: 'GET',
      signal: ac.signal,
      cache: 'no-store',
    })
    const data = await handleResponse(r)
    return Response.json(data)
  } catch (e) {
    const msg = e instanceof DOMException && e.name === 'AbortError'
      ? 'タイムアウトしました。ネットワーク状況を確認してください。'
      : e instanceof Error ? e.message : '処理中にエラーが発生しました。'
    return Response.json({ error: msg }, { status: 500 })
  } finally {
    clearTimeout(t)
  }
}

// hooks/useInitialSync.ts
import { useEffect } from 'react'

export function useInitialSync(
  fetchUrl: string,
  onSuccess: (data: any) => void,
  onError?: (msg: string) => void
) {
  useEffect(() => {
    const ac = new AbortController()
    let cancelled = false
    ;(async () => {
      try {
        const res = await fetch(fetchUrl, { signal: ac.signal, cache: 'no-store' })
        if (!res.ok) {
          let detail = 'Unknown error'
          try { const err = await res.json(); detail = err.error || err.detail || detail } catch {}
          throw new Error(detail)
        }
        const data = await res.json()
        if (!cancelled) onSuccess(data)
      } catch (e) {
        if (!cancelled) onError?.(e instanceof Error ? e.message : 'Unknown error')
      }
    })()
    return () => { cancelled = true; ac.abort() }
  }, [fetchUrl, onSuccess, onError])
}

使用例（UIの都合に整形してStateへ）
// 任意のコンポーネント
useInitialSync('/api/any', (data) => {
  const names: string[] = Array.isArray(data.items) ? data.items.map((x: any) => String(x.name)) : []
  setNames(names)
  setReady(names.length > 0)
}, (msg) => console.error('initial sync failed:', msg))

function toNames(payload: unknown): string[] {
  const items = (payload as any)?.items
  if (!Array.isArray(items)) return []
  return items.map((x: any) => String(x?.name ?? ''))
}
const names = toNames(data)
const ready = names.length > 0

const msg = e instanceof DOMException && e.name === 'AbortError'
  ? 'タイムアウトしました。ネットワーク状況を確認してください。'
  : e instanceof Error ? e.message : '処理中にエラーが発生しました。'

npm i zustand
# 任意: 永続化やDevTools等のミドルウェア
npm i zustand@latest

'use client'

import { create } from 'zustand'

type CounterState = {
  count: number
  inc: () => void
}

export const useCounter = create<CounterState>((set) => ({
  count: 0,
  inc: () => set((s) => ({ count: s.count + 1 })),
}))

const count = useCounter((s) => s.count)
const inc = useCounter((s) => s.inc)

import { create } from 'zustand'
import { persist } from 'zustand/middleware'

type SettingsState = {
  topK: number
  setTopK: (n: number) => void
}

export const useSettingsStore = create<SettingsState>()(
  persist(
    (set) => ({
      topK: 5,
      setTopK: (n) => set({ topK: Math.max(1, n) }),
    }),
    { name: 'settings' } // localStorage key
  )
)

import { shallow } from 'zustand/shallow'

const { a, b } = useStore((s) => ({ a: s.a, b: s.b }), shallow)

import { devtools, persist, immer } from 'zustand/middleware'

export const useStore = create<State>()(
  devtools(
    persist(
      immer((set) => ({ /* ... */ })),
      { name: 'app-store' }
    ),
    { name: 'AppStore' }
  )
)

type UserState = {
  user?: { id: string; name: string }
  fetchUser: (id: string) => Promise<void>
}

export const useUser = create<UserState>((set) => ({
  user: undefined,
  fetchUser: async (id) => {
    const res = await fetch(`/api/users/${id}`)
    const data = await res.json()
    set({ user: data })
  },
}))

type BearSlice = { bears: number; addBear: () => void }
type FishSlice = { fish: number; addFish: () => void }
type Store = BearSlice & FishSlice

const createBearSlice = (set): BearSlice => ({
  bears: 0,
  addBear: () => set((s: Store) => ({ bears: s.bears + 1 })),
})

const createFishSlice = (set): FishSlice => ({
  fish: 0,
  addFish: () => set((s: Store) => ({ fish: s.fish + 1 })),
})

export const useStore = create<Store>()((set) => ({
  ...createBearSlice(set),
  ...createFishSlice(set),
}))

'use client'
import { create } from 'zustand'
import { persist } from 'zustand/middleware'

type SettingsState = {
  topK: number
  setTopK: (n: number) => void
}

export const useSettingsStore = create<SettingsState>()(
  persist(
    (set) => ({
      topK: 5,
      setTopK: (n) => {
        const v = Number.isFinite(n) ? n : 5
        const clamped = Math.min(20, Math.max(1, v))
        set({ topK: clamped })
      },
    }),
    { name: 'settings' }
  )
)

import { useSettingsStore } from '@/lib/settings-store'
import { Slider } from '@/components/ui/slider'

const topK = useSettingsStore((s) => s.topK)
const setTopK = useSettingsStore((s) => s.setTopK)

<Slider value={[topK]} onValueChange={(v) => setTopK(v[0] ?? 5)} min={1} max={20} step={1} />

const topK = useSettingsStore((s) => s.topK)

await fetch('/api/chat', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ messages, askToBot, model, top_k: topK }),
})

import { useSettingsStore } from './settings-store'

test('setTopK clamps value', () => {
  const { setTopK, topK } = useSettingsStore.getState()
  setTopK(0)
  expect(useSettingsStore.getState().topK).toBeGreaterThanOrEqual(1)
})