remove nav_bridge.py and update dependencies in pyproject.toml and README.md to reflect changes in navigation API endpoints and session management

README.md

@@ -27,15 +27,17 @@ uvicorn server:app --reload
 API 문서는 `http://localhost:8000/docs`에서 확인할 수 있습니다.
 
 ## API 엔드포인트
-### POST `/api/navigation/step`
-
-네비게이션 단계별 안내를 요청
 
-**요청:**
-- `request_text` (Form): 자연어 요청 텍스트
-- `image` (File): 현장 이미지 파일
+### POST `/api/navigation/start`
+- 자연어 요청과 시작 방, 현장 이미지를 받아 네비게이션 세션을 생성하고 첫 안내를 반환
+- Form 데이터: `request_text`(자연어 요청), `start_room`(시작 방 번호), File: `image`(현장 이미지)
+- 응답: 첫 네비게이션 안내(JSON). 세션 상태가 `CAAINP-NAVIGATION-COOKIE`에 저장됨.
 
-**응답 예시:**
+### POST `/api/navigation/step`
+- 쿠키에 저장된 세션 상태(plan, prev_node)를 사용해 다음 단계 안내를 반환
+- File: `image`(현장 이미지)
+- 세션이 없으면 `{ "status": "error", "message": "/api/navigation/start를 먼저 호출하세요." }` 반환
+- 응답 예시:
 ```json
 {
   "schema_version": 1,
@@ -55,6 +57,28 @@ API 문서는 `http://localhost:8000/docs`에서 확인할 수 있습니다.
 }
 ```
 
+### POST `/api/navigation/reset`
+- 저장된 네비게이션 쿠키 삭제 후 세션 초기화
+- 응답: `{ "status": "success", "message": "네비게이션 세션이 초기화되었습니다." }`
+
+### POST `/api/navigation/mock`
+- 실제 엔진 대신 모의 응답 반환(디버깅/프론트엔드 연동용)
+- Form: `request_text`, File: `image`
+- 응답: 모의 네비게이션 JSON
+
+### GET `/api/cookie/get`
+- 현재 요청의 `CAAINP-NAVIGATION-COOKIE` 값을 조회
+- 응답: `{ "cookie": {plan, prev_node} | null }`
+
+### GET `/api/cookie/delete`
+- 네비게이션 쿠키 삭제
+- 응답: `{ "status": "success", "message": "쿠키가 성공적으로 삭제되었습니다." }`
+
+## 테스트
+```bash
+uv run tests/navigation_test.py
+```
+
 ## 프로젝트 구조
 
 ```
@@ -64,3 +88,4 @@ caanip-backend/
 ├── pyproject.toml         # 프로젝트 설정 및 의존성
 └── README.md             # 프로젝트 문서
 ```
+

core/cookie.py

@@ -0,0 +1,109 @@
+from fastapi import Request, Response
+from caainp_csm.plan_csm import PlanState, Constraints, Step
+import json
+
+COOKIE_KEY = "CAAINP-NAVIGATION-COOKIE"
+
+
+def plan_to_dict(plan: PlanState) -> dict:
+    """PlanState를 JSON 직렬화 가능한 dict로 변환"""
+    return {
+        "constraints": {
+            "use_elevator_only": plan.constraints.use_elevator_only,
+            "avoid_stairs": plan.constraints.avoid_stairs,
+            "forbidden_nodes": plan.constraints.forbidden_nodes,
+            "via_rooms": plan.constraints.via_rooms,
+        },
+        "steps": [
+            {
+                "step_id": s.step_id,
+                "goal_type": s.goal_type,
+                "goal_room": s.goal_room,
+                "allowed_moves": s.allowed_moves,
+                "description_ko": s.description_ko,
+                "target_nodes": s.target_nodes,
+                "route_nodes": s.route_nodes,
+            }
+            for s in plan.steps
+        ],
+        "current_step": plan.current_step,
+        "steps_status": plan.steps_status,
+        "step_targets": {str(k): v for k, v in plan.step_targets.items()},
+        "in_target_count": plan.in_target_count,
+    }
+
+
+def dict_to_plan(data: dict) -> PlanState:
+    """dict를 PlanState 객체로 복원"""
+    constraints = Constraints(
+        use_elevator_only=data["constraints"]["use_elevator_only"],
+        avoid_stairs=data["constraints"]["avoid_stairs"],
+        forbidden_nodes=data["constraints"]["forbidden_nodes"],
+        via_rooms=data["constraints"]["via_rooms"],
+    )
+    
+    steps = [
+        Step(
+            step_id=s["step_id"],
+            goal_type=s["goal_type"],
+            goal_room=s["goal_room"],
+            allowed_moves=s["allowed_moves"],
+            description_ko=s["description_ko"],
+            target_nodes=s["target_nodes"],
+            route_nodes=s["route_nodes"],
+        )
+        for s in data["steps"]
+    ]
+    
+    # steps_status의 키를 int로 복원
+    steps_status = {int(k): v for k, v in data["steps_status"].items()}
+    # step_targets의 키를 int로 복원
+    step_targets = {int(k): v for k, v in data["step_targets"].items()}
+    
+    return PlanState(
+        constraints=constraints,
+        steps=steps,
+        current_step=data["current_step"],
+        steps_status=steps_status,
+        step_targets=step_targets,
+        in_target_count=data["in_target_count"],
+    )
+
+
+def get_nav_state_from_cookie(request: Request) -> tuple[PlanState, int] | None:
+    """쿠키에서 네비게이션 상태를 읽어서 반환"""
+    cookies = dict(request.cookies)
+    nav_state_cookie = cookies.get(COOKIE_KEY)
+    
+    if not nav_state_cookie:
+        return None
+    
+    try:
+        nav_state = json.loads(nav_state_cookie)
+        plan_dict = nav_state.get("plan")
+        prev_node = nav_state.get("prev_node")
+        plan = dict_to_plan(plan_dict)
+        return plan, prev_node
+    except (json.JSONDecodeError, KeyError, TypeError):
+        return None
+
+
+def save_nav_state_to_cookie(response: Response, plan: PlanState, prev_node: int) -> None:
+    """네비게이션 상태(plan, prev_node)를 쿠키에 저장"""
+    nav_state = {
+        "plan": plan_to_dict(plan),
+        "prev_node": prev_node,
+    }
+    response.set_cookie(
+        key=COOKIE_KEY,
+        value=json.dumps(nav_state),
+        max_age=3600,
+        httponly=True,
+        samesite="lax"
+    )
+
+
+def clear_nav_cookie(response: Response) -> None:
+    """네비게이션 쿠키 삭제"""
+    response.delete_cookie(COOKIE_KEY)
+

core/navigation.py

@@ -0,0 +1,39 @@
+from caainp_csm.plan_csm import PlanState
+from caainp_cvm.nav_engine import init_plan, compute_nav_output, _get_csv_path
+
+CSV_PATH = _get_csv_path()
+
+# 네비게이션 시작
+def start_navigation(user_text: str, start_room: int, image_path: str):
+    plan, _ = init_plan(
+        user_text=user_text,
+        start_room=start_room,
+    )
+    
+    out = compute_nav_output(
+        image_path=str(image_path),
+        plan=plan,
+        prev_node=None,
+        csv_path=str(CSV_PATH),
+    )
+
+    nav_output = out["nav_output"]
+    plan = out["plan"]
+    prev_node = nav_output["current_node"]
+    
+    return plan, nav_output, prev_node
+
+# 쿠키 값에 저장된 plan, prev_node이 있다면 compute_nav_output 함수를 통해 네비게이션 결과를 반환
+def navigation_step(plan, prev_node, image_path: str):
+    out = compute_nav_output(
+        image_path=str(image_path),
+        plan=plan,
+        prev_node=prev_node,
+        csv_path=str(CSV_PATH),
+    )
+
+    nav_output = out["nav_output"]
+    plan = out["plan"]
+    prev_node = nav_output["current_node"]
+    
+    return plan, nav_output, prev_node

pyproject.toml

@@ -8,4 +8,11 @@ dependencies = [
     "fastapi>=0.123.10",
     "uvicorn>=0.38.0",
     "python-multipart>=0.0.6",
+    "caainp-csm",
+    "caainp-cvm",
 ]
+
+[tool.uv.sources]
+caainp-csm = { git = "https://github.com/caainp/caainp-csm.git" }
+caainp-cvm = { git = "https://github.com/caainp/caainp-cvm.git" }
+

routes/cookie.py

@@ -0,0 +1,26 @@
+from fastapi import APIRouter, Request, Response
+from core.cookie import (
+    get_nav_state_from_cookie,
+    save_nav_state_to_cookie,
+    clear_nav_cookie,
+    COOKIE_KEY,
+)
+
+router = APIRouter(prefix="/api/cookie", tags=["cookie"])
+
+@router.get("/get")
+async def cookie_get(request: Request):
+    """쿠키 읽기 테스트 엔드포인트"""
+    cookies = dict(request.cookies)
+    return {
+        "cookie": cookies.get(COOKIE_KEY)
+    }
+    
+@router.get("/delete")
+async def cookie_delete(request: Request, response: Response):
+    """쿠키 삭제 테스트 엔드포인트"""
+    clear_nav_cookie(response)
+    return {
+        "status": "success",
+        "message": "쿠키가 성공적으로 삭제되었습니다."
+    }

routes/navigation.py

@@ -0,0 +1,108 @@
+from fastapi import APIRouter, UploadFile, File, Form, Request, Response
+from core.navigation import start_navigation, navigation_step as nav_step
+from core.cookie import (
+    get_nav_state_from_cookie,
+    save_nav_state_to_cookie,
+    clear_nav_cookie,
+)
+from mock_responses import generate_mock_navigation_response
+import tempfile
+import os
+
+router = APIRouter(prefix="/api/navigation", tags=["navigation"])
+
+
+@router.post("/step")
+async def navigation_step_route(
+    request: Request,
+    response: Response,
+    image: UploadFile = File(..., description="이미지"),
+):
+    # 쿠키에서 plan과 prev_node 읽기
+    nav_state = get_nav_state_from_cookie(request)
+    
+    if not nav_state:
+        return {
+            "status": "error",
+            "message": "네비게이션 세션이 없습니다. /api/navigation/start를 먼저 호출하세요."
+        }
+    
+    plan, prev_node = nav_state
+    
+    # 이미지를 임시 파일로 저장
+    image_content = await image.read()
+    with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(image.filename)[1]) as tmp_file:
+        tmp_file.write(image_content)
+        tmp_path = tmp_file.name
+    
+    try:
+        # navigation_step 호출
+        plan, nav_output, prev_node = nav_step(
+            plan=plan,
+            prev_node=prev_node,
+            image_path=tmp_path,
+        )
+        
+        # 쿠키에 상태 저장
+        save_nav_state_to_cookie(response, plan, prev_node)
+        
+        return nav_output
+    finally:
+        # 임시 파일 삭제
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+
+
+@router.post("/start")
+async def navigation_start_route(
+    response: Response,
+    request_text: str = Form(..., description="자연어 요청"),
+    start_room: int = Form(..., description="시작 방"),
+    image: UploadFile = File(..., description="이미지"),
+):
+    # 기존 쿠키 초기화 (새 세션 시작)
+    clear_nav_cookie(response)
+    
+    # 이미지를 임시 파일로 저장
+    image_content = await image.read()
+    with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(image.filename)[1]) as tmp_file:
+        tmp_file.write(image_content)
+        tmp_path = tmp_file.name
+    
+    try:
+        # start_navigation 호출
+        plan, nav_output, prev_node = start_navigation(
+            user_text=request_text,
+            start_room=start_room,
+            image_path=tmp_path,
+        )
+        
+        # 쿠키에 상태 저장
+        save_nav_state_to_cookie(response, plan, prev_node)
+        
+        return nav_output
+    finally:
+        # 임시 파일 삭제
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+
+
+@router.post("/reset")
+async def navigation_reset_route(
+    response: Response,
+):
+    clear_nav_cookie(response)
+    return {
+        "status": "success",
+        "message": "네비게이션 세션이 초기화되었습니다."
+    }
+
+@router.post("/mock")
+async def navigation_mock(
+    request_text: str = Form(..., description="자연어 요청"),
+    image: UploadFile = File(..., description="이미지"),
+):
+    await image.read()
+    response = generate_mock_navigation_response()
+    return response
+

server.py

@@ -1,22 +1,19 @@
-from fastapi import FastAPI, UploadFile, File, Form
+from fastapi import FastAPI, Request, Response
 from datetime import datetime
-from mock_responses import generate_mock_navigation_response
+from routes.navigation import router as navigation_router
+from routes.cookie import router as cookie_router
+import uuid
 
 app = FastAPI()
 
+# 라우터 등록
+app.include_router(navigation_router)
+app.include_router(cookie_router)
+
 @app.get("/api/health")
 def health_check():
     return {
         "status": "healthy",
         "timestamp": datetime.now().isoformat(),
         "service": "caanip-backend"
-    }   
-
-@app.post("/api/navigation/step")
-async def navigation_step(
-    request_text: str = Form(..., description="자연어 요청"),
-    image: UploadFile = File(..., description="이미지"),
-):
-    await image.read()
-    response = generate_mock_navigation_response()
-    return response
+    }

nav_bridge.py → tests/navigation_test.py

@@ -4,43 +4,26 @@ import sys
 # 현재 파일 위치: .../nav/caanip-backend/nav_bridge.py
 THIS_DIR = Path(__file__).resolve().parent
 BACKEND_ROOT = THIS_DIR              # .../caanip-backend
-NAV_ROOT = BACKEND_ROOT.parent       # .../nav (caainp-csm, caainp-cvm, caanip-backend 상위 디렉토리)
 
-# 1) CSM(src) / CVM(nav_engine) 경로를 파이썬 모듈 검색 경로에 추가
-CSM_SRC = NAV_ROOT / "caainp-csm" / "src"
-CVM_ROOT = NAV_ROOT / "caainp-cvm"
-
-sys.path.append(str(CSM_SRC))
-sys.path.append(str(CVM_ROOT))
-
-# 2) CSM 모듈을 nav_engine과 동일한 방식으로 직접 import
-from graph_4f import Graph4F
-from plan_csm import (
-    Constraints,
-    Step,
-    PlanState,
-    create_simple_plan,
-    update_state_with_node,
-)
-
-# 3) CVM 쪽 nav_engine에서 엔진 함수 import
-from nav_engine import init_plan, compute_nav_output
+from caainp_csm.graph_4f import Graph4F
+from caainp_csm.plan_csm import (Constraints, Step, PlanState, create_simple_plan, update_state_with_node)
+from caainp_cvm.nav_engine import init_plan, compute_nav_output, _get_csv_path
 
+CSV_PATH = _get_csv_path()
 
 def quick_test():
     """
     backend 레포에서 CSM + CVM + nav_engine이 제대로 연결되는지 확인용.
     실제 FastAPI 코드에서는 init_plan / compute_nav_output만 가져다 쓰면 됨.
     """
-    # 1) 플랜 초기화 (CSM)
-    plan, csv_path = init_plan(
+    
+    plan = init_plan(
         user_text="401에서 410호까지 이동",
         start_room=401,
     )
 
-    # 2) CVM 이미지 경로 설정 (caainp-cvm/nav_engine.py에서 쓰던 node_images 기준)
-    node_images_dir = CVM_ROOT / "node_images" / "node_images"
-    img_seq = ["401.jpg", "4102.jpg", "4201.jpg"]
+    node_images_dir = BACKEND_ROOT / "images"
+    img_seq = ["401(1).jpg", "403(3).jpg", "410(1).jpg"]
 
     prev_node = None
 
@@ -51,7 +34,7 @@ def quick_test():
             image_path=str(image_path),
             plan=plan,          # PlanState 객체 (우리가 nav_engine에서 쓰는 버전 기준)
             prev_node=prev_node,
-            csv_path=str(csv_path),
+            csv_path=str(CSV_PATH),
         )
 
         nav_output = out["nav_output"]
@@ -62,6 +45,5 @@ def quick_test():
         print(f"\n[IMAGE] {img_name}")
         pprint(nav_output)
 
-
 if __name__ == "__main__":
     quick_test()