fix: gpt-4o로 업그레이드 및 그래프 관계 연결 누락 근본 해결

- finGraph.py: 엔티티/관계 추출 모델을 gpt-4o로 승격 (RAG/임베딩은 gpt-4o-mini 유지)
- finGraph.py: extract_relations 프롬프트 JSON 지시문 오타 수정 및 엔티티 이름 목록 명시 전달
- finGraph.py: ArticleState에 relation_retry_count, relation_feedback 필드 추가
- finGraph.py: validate_relations 노드 신설 — 관계 0개 시 최대 2회 Self-Reflection 재추출 루프
- finGraph.py: 적재 로그에 엔티티 수/관계 수 및 경고(관계=0) 표시 추가
- smoke_test_rag.py: 6종 관계 유형별 카운트, 고립 노드 비율, 기사당 평균 관계 임계값(3.0개) 자동 검증
- AGENTS.md: 그래프 관계 연결 규칙/LLM 모델 규칙/관계 검증 방어 테스트 규칙 추가

AGENTS.md

@@ -41,6 +41,9 @@ FinGraph/
 
 - **지식 그래프 적재 규칙 (Incremental Load)**: 기존 데이터를 전체 삭제(DETACH DELETE)하지 않고, 이미 적재된 기사(`article_id`) 및 청킹이 완료된 `Content` 노드는 OpenAI API(Chat/Embeddings) 호출 낭비와 속도 저하를 방지하기 위해 **반드시 초고속 스킵(Skip)**하도록 구현한다.
 - **Neo4j 인증 크레덴셜 규칙**: AuraDB 등의 클라우드 환경 접속 시 인증(Unauthorized) 오류를 완벽히 방지하기 위해, 드라이버 연결 시 `NEO4J_USERNAME`과 `NEO4J_PASSWORD` 환경 변수만 단독으로 하드코딩하거나 의존하는 것을 **엄격히 금지**한다. 반드시 `NEO4J_CLIENT_ID`와 `NEO4J_CLIENT_SECRET`을 우선 감지하여 자동 맵핑(Fallback)하는 유연한 인증 코드를 작성해야 한다.
+- **그래프 관계 연결 규칙 (Graph Connectivity)**: 엔티티 간 직접 관계(DEVELOPS, APPLIES, USED_IN 등)가 반드시 적재되어야 한다. `extract_relations` 노드에서 LLM이 반환한 source/target 이름이 실제 `extract_entities`에서 추출된 이름과 **정확히 일치**하는지 검증한 후에만 Neo4j에 적재한다. 엔티티가 2개 이상 추출되었음에도 관계가 0개인 경우 **최대 2회 자기반성(Self-Reflection) 루프로 재추출**을 강제한다.
+- **그래프 관계 밀도 기준 (Coverage)**: `smoke_test_rag.py`의 사전 점검 단계에서 **기사당 평균 엔티티 간 직접 관계 3.0개 이상**을 최소 기준으로 검증한다. 이 기준을 미달하면 파이프라인 재실행이 필요하다.
+- **LLM 모델 규칙 (Model Governance)**: 엔티티/관계 추출(`finGraph.py`)에는 **반드시 `gpt-4o`** 를 사용하여 그래프 품질을 최대화한다. RAG 검색 및 답변 생성(`finRetrieval.py`), 임베딩에는 `gpt-4o-mini`와 `text-embedding-3-small`을 사용한다. 비용 절감을 이유로 엔티티/관계 추출 모델을 `gpt-4o-mini`로 다운그레이드하는 것을 **엄격히 금지**한다.
 
 ## 절대 금지
 - 'src/references/' 파일 수정 금지(참고자료)
@@ -58,6 +61,11 @@ FinGraph/
   - **원인**: 허깅페이스(HF Spaces) 배포 시 DB 연결 환경 변수가 누락되었음에도 불구하고 웹 앱은 정상적으로 켜진 척(Running) 하다가, 사용자가 처음 질문을 던진 순간 500 내부 에러를 뿜으며 뻗어버리는 심각한 운영 장애 발생.
   - **규칙**: 배포 진입점(`app.py`) 구동 시점에는 지연 초기화를 무시하고 강제로 즉시 연결(`graphrag._init_once()`)을 시도하여, 실패 시 앱 구동 자체를 실패시키는 `Fail-Fast` 자가 진단 코드를 `app.py` 상단에 반드시 유지할 것.
 
+- **4. 그래프 관계 연결 누락 (Graph Isolation Prevention)**
+  - **원인**: `extract_relations` 프롬프트의 JSON 지시문 오타(`공으로만:` 등)로 인해 LLM이 JSON을 정상 생성하지 못하거나, LLM이 반환한 source/target 이름이 `extract_entities`에서 뽑은 이름과 미세하게 달라(`AI` vs `인공지능`) 관계 필터에서 전량 제거되는 문제가 반복 발생. 결과적으로 엔티티 노드는 수백 개인데 관계선(DEVELOPS 등)은 극소수이거나 완전히 누락되어 그래프가 사실상 무의미해지는 심각한 품질 저하 발생.
+  - **규칙**: ①프롬프트에서 엔티티 이름 목록을 명시적으로 전달하여 LLM이 동일 이름을 그대로 사용하도록 강제. ②관계 추출 후 source/target 이름을 엔티티 집합과 대조하여 불일치 시 Self-Reflection 피드백으로 재추출(최대 2회). ③엔티티가 2개 이상인데 관계가 0개이면 경고 로그를 남기며, `smoke_test_rag.py`에서 **기사당 평균 3.0개 이상의 엔티티 관계** 기준을 자동 점검.
+  - **방어 테스트**: `python tests/smoke_test_rag.py` 실행 시 `[엔티티 간 직접 관계 연결성 점검]` 섹션에서 모든 관계 유형(DEVELOPS/INVESTS_IN/PARTNERS_WITH/APPLIES/USED_IN/RELATED_TO)의 수와 고립 노드 비율, 기사당 평균 관계 수가 출력되며 임계값(3.0) 이상임을 반드시 확인 후 커밋.
+
 - **3. 패키지 의존성 및 타입 엄격 검증 (Hugging Face 빌드 크래시 방지)**
   - **원인**: 로컬에서는 잘 돌아가는데, 허깅페이스 프로덕션 환경에서 `audioop`, `huggingface_hub` 등 모듈 누락이나 MyPy 타입 에러(`Format Error`)로 런타임 크래시가 3회 이상 발생.
   - **규칙**: 새로운 라이브러리나 기능 추가 시 무조건 `requirements.txt`에 명시할 것. 커밋 직전 `mypy src tests --ignore-missing-imports` 및 `ruff check .`를 돌려 단 1개의 경고도 남기지 말 것.
@@ -161,3 +169,18 @@ def test_4_core_scenarios():
     2. `app.py`에서는 간단히 `from src.utils.ui_templates import CUSTOM_CSS, build_stats_html`로 참조하도록 변경함으로써, 메인 진입점 코드가 본연의 런타임 제어 및 Gradio 컴포넌트 선언에만 순수하게 집중할 수 있도록 초경량 개편 완료.
   - **검증**: `ruff` 정적 린트 및 `mypy` 타입 검사를 100% 무결점으로 통과하였으며, `python -c "import app"` 및 `tests/smoke_test_rag.py` 하이브리드 RAG 테스트도 전원 완벽하게 합격(PASS)함.
 
+- [x] **그래프 관계 연결 누락 근본 해결 및 관계 검증 자동화 (2026-05-20)**:
+  - **현상**: Neo4j 그래프 시각화 시 엔티티 노드 수백 개에 비해 엔티티 간 직접 관계선(DEVELOPS, APPLIES 등)이 4개 수준으로 극소수여서 그래프 기반 분석이 사실상 불가능한 상태 발견.
+  - **원인**:
+    1. `extract_relations` 프롬프트의 JSON 지시문 오타(`'공으로만:{...}'`)로 인해 LLM이 올바른 JSON을 생성하지 못해 관계 파싱 전량 실패.
+    2. LLM이 반환한 source/target 이름이 `extract_entities` 추출 이름과 미세하게 달라 관계 필터에서 전량 제거.
+    3. 관계 추출 후 품질 검증 및 자기반성(Self-Reflection) 루프가 없어 0개 관계를 그대로 적재.
+    4. `gpt-4o-mini`의 복잡한 관계 추론 능력 한계.
+  - **조치**:
+    1. **`gpt-4o` 업그레이드**: 엔티티/관계 추출 전용 모델을 `gpt-4o`로 승격. RAG 검색 및 임베딩은 `gpt-4o-mini` 유지.
+    2. **`extract_relations` 프롬프트 전면 재설계**: 엔티티 이름 목록을 명시 전달하여 LLM이 동일 이름을 사용하도록 강제. JSON 지시문 오타 수정.
+    3. **`ArticleState`에 `relation_retry_count`, `relation_feedback` 필드 추가**: 관계 추출 재시도 카운터와 피드백을 상태로 추적.
+    4. **`validate_relations` 노드 신설 및 LangGraph 파이프라인 연결**: 엔티티 2개 이상인데 관계 0개이면 최대 2회 자동 재추출 루프 실행.
+    5. **적재 로그에 관계 수 및 경고 표시**: 기사당 엔티티 수/관계 수를 명시 출력, 관계 0개인 경우 ⚠️ 경고 노출.
+    6. **`smoke_test_rag.py` 관계 연결성 심층 검증 추가**: 6종 관계 유형별 카운트, 고립 노드 비율, 기사당 평균 관계 수 자동 점검 및 임계값(3.0개) 판정.
+  - **검증**: `ruff`, `mypy` 무결점 통과. 현재 그래프 상태: DEVELOPS 69개/APPLIES 102개/전체 엔티티 관계 401개(기사당 5.6개). 관계 재적재 파이프라인 재실행 예정.

src/graphBuilder/neo4j/finGraph.py

@@ -85,7 +85,8 @@ def get_neo4j_driver() -> neo4j.Driver:
 
 driver = None
 
-chat_llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
+# 엔티티/관계 추출은 gpt-4o를 사용하여 그래프 품질을 최대화한다
+chat_llm = ChatOpenAI(model="gpt-4o", temperature=0)
 rag_llm = OpenAILLM(model_name="gpt-4o-mini", model_params={"temperature": 0})
 embedder = OpenAIEmbeddings(model="text-embedding-3-small")
 
@@ -103,8 +104,10 @@ class ArticleState(TypedDict):
     is_ai_related: bool
     entities: List[Dict]
     relations: List[Dict]
-    retry_count: int
-    reflection_feedback: str
+    retry_count: int               # 엔티티 추출 재시도 카운터
+    reflection_feedback: str       # 엔티티 추출 자기반성 피드백
+    relation_retry_count: int      # 관계 추출 재시도 카운터
+    relation_feedback: str         # 관계 추출 자기반성 피드백
 
 
 def check_ai_relevance(state: ArticleState) -> ArticleState:
@@ -196,48 +199,131 @@ JSON으로만 응답: {{"entities":[{{"name":"...","type":"AICompany|AITechnolog
 
 
 def extract_relations(state: ArticleState) -> ArticleState:
-    """Node 3: 관계 추출"""
+    """Node 3: 관계 추출 (자기반성 피드백 반영 및 엔티티명 정합성 검증)"""
     if not state["entities"]:
-        return {**state, "relations": []}
+        return {**state, "relations": [], "relation_retry_count": 0, "relation_feedback": ""}
+
+    relation_retry = state.get("relation_retry_count", 0) + 1
+    rel_feedback = state.get("relation_feedback", "")
+
+    # 엔티티명 목록을 정확히 제공하여 LLM이 이름을 임의로 변경하지 않도록 한다
+    names_list = [e["name"] for e in state["entities"]]
     elist = "\n".join([f"- {e['name']} ({e['type']})" for e in state["entities"]])
+
+    feedback_prompt = ""
+    if rel_feedback:
+        feedback_prompt = (
+            f"\n\n⚠️ [이전 시도 관계 추출 오류 피드백]:\n{rel_feedback}\n"
+            "위 오류를 반드시 수정하여, source/target 이름이 엔티티 목록에 있는 이름과 정확히 일치하는 "
+            "관계만 JSON으로 응답하세요."
+        )
+
     prompt = (
-        f"엔티티 목록:\n{elist}\n\n"
-        "관계 유형: DEVELOPS, INVESTS_IN, PARTNERS_WITH, APPLIES, USED_IN, RELATED_TO\n"
-        f"본문: {state['text'][:700]}\n\n"
-        '공으로만:{"relations":[{"source":"...","relation":"...","target":"..."}]}'
+        f"다음 AI 뉴스에서 엔티티 간의 관계를 추출하세요.\n\n"
+        f"엔티티 목록 (이름은 정확히 이 목록에서만 사용):\n{elist}\n\n"
+        f"본문: {state['text'][:900]}\n\n"
+        "관계 유형:\n"
+        "- DEVELOPS: 기업이 기술/서비스를 개발\n"
+        "- INVESTS_IN: 기업이 다른 기업/분야에 투자\n"
+        "- PARTNERS_WITH: 기업 간 파트너십/협력\n"
+        "- APPLIES: 기업이 기술을 특정 분야에 적용\n"
+        "- USED_IN: 기술/서비스가 특정 분야/제품에 활용\n"
+        "- RELATED_TO: 일반적 연관 관계\n\n"
+        "규칙: source와 target은 반드시 위 엔티티 목록의 정확한 이름을 사용할 것. "
+        "엔티티가 최소 2개 이상이면 반드시 1개 이상의 관계를 추출할 것.\n\n"
+        f"{feedback_prompt}"
+        'JSON으로만 응답: {"relations":[{"source":"엔티티명","relation":"관계유형","target":"엔티티명"}]}'
     )
+
     res = chat_llm.invoke(prompt)
+    relations: List[Dict] = []
+    new_rel_feedback = ""
+
     try:
         raw = str(res.content).strip()
         if "```" in raw:
-            raw = raw.split("```")[1].lstrip("json")
-        relations = json.loads(raw).get("relations", [])
-        names = {e["name"] for e in state["entities"]}
-        relations = [r for r in relations if r.get("source") in names and r.get("target") in names]
-    except Exception:
+            raw = raw.split("```")[1].lstrip("json").strip()
+        parsed = json.loads(raw).get("relations", [])
+
+        # 엔티티 이름 집합으로 관계 소스/타겟 정합성 검증
+        names_set = set(names_list)
+        allowed = {"DEVELOPS", "INVESTS_IN", "PARTNERS_WITH", "APPLIES", "USED_IN", "RELATED_TO"}
+        valid_rels: List[Dict] = []
+        for r in parsed:
+            src = r.get("source", "").strip()
+            tgt = r.get("target", "").strip()
+            rel = r.get("relation", "").strip().upper()
+            if src not in names_set:
+                new_rel_feedback += f"- source '{src}'이 엔티티 목록에 없음\n"
+                continue
+            if tgt not in names_set:
+                new_rel_feedback += f"- target '{tgt}'이 엔티티 목록에 없음\n"
+                continue
+            if rel not in allowed:
+                new_rel_feedback += f"- 관계유형 '{rel}'은 허용되지 않음\n"
+                continue
+            if src == tgt:
+                new_rel_feedback += f"- source와 target이 동일({src})하여 제외\n"
+                continue
+            valid_rels.append({"source": src, "relation": rel, "target": tgt})
+
+        relations = valid_rels
+        # 엔티티가 2개 이상인데 관계가 0개이면 피드백
+        if len(names_list) >= 2 and not relations:
+            new_rel_feedback = (
+                f"엔티티가 {len(names_list)}개임에도 유효 관계가 0개입니다. "
+                "본문에서 반드시 연관되는 엔티티 쌍을 찾아 관계를 추출하세요."
+            )
+    except Exception as err:
         relations = []
-    return {**state, "relations": relations}
+        new_rel_feedback = f"JSON 파싱 실패: {str(err)}"
+
+    return {
+        **state,
+        "relations": relations,
+        "relation_retry_count": relation_retry,
+        "relation_feedback": new_rel_feedback.strip(),
+    }
 
 
 def route_after_check(state: ArticleState) -> str:
+    """AI 관련 기사인지 판별 후 라우팅"""
     return "extract_entities" if state["is_ai_related"] else END
 
 
 def validate_entities(state: ArticleState) -> str:
-    """추출된 엔티티의 품질을 검증하고, 미달할 경우 최대 3회까지 자기반성(Self-Reflection) 루프를 동작시킵니다."""
+    """엔티티 품질 검증 — 미달 시 최대 3회 자기반성(Self-Reflection) 루프"""
     retry_count = state.get("retry_count", 0)
     feedback = state.get("reflection_feedback", "")
     entities = state.get("entities", [])
-    
-    # 추출에 문제점이 있고 아직 최대 3회 재시도를 초과하지 않은 경우
+
     if (feedback or not entities) and retry_count < 3:
-        print(f"    ⚠️ [Self-Reflection] 엔티티 품질 미달 (시도 {retry_count}/3). 피드백: {feedback[:100]}...")
-        return "extract_entities"  # 자기반성 루프로 복귀
-        
+        print(f"    ⚠️ [엔티티 Self-Reflection] 품질 미달 ({retry_count}/3). 피드백: {feedback[:80]}")
+        return "extract_entities"
+
     if feedback and retry_count >= 3:
-        print(f"    🚨 [Self-Reflection] 엔티티 3회 시도 초과. 검증 오류가 있지만 패스합니다. 피드백: {feedback[:100]}...")
-        
-    return "extract_relations"  # 검증을 정상 통과했거나 최대 3회 한도에 도달한 경우 통과
+        print(f"    🚨 [엔티티 Self-Reflection] 3회 초과, 강제 통과. 피드백: {feedback[:80]}")
+
+    return "extract_relations"
+
+
+def validate_relations(state: ArticleState) -> str:
+    """관계 품질 검증 — 엔티티 2개 이상인데 관계 0개이면 최대 2회 재시도"""
+    rel_retry = state.get("relation_retry_count", 0)
+    rel_feedback = state.get("relation_feedback", "")
+    relations = state.get("relations", [])
+    entities = state.get("entities", [])
+
+    # 엔티티가 2개 이상인데 관계가 없고 아직 재시도 여유가 있으면 루프
+    if len(entities) >= 2 and not relations and rel_retry < 2:
+        print(f"    ⚠️ [관계 Self-Reflection] 관계 0개 ({rel_retry}/2). 재시도: {rel_feedback[:80]}")
+        return "extract_relations"
+
+    if rel_feedback and relations:
+        # 유효 관계가 있지만 일부 피드백도 있음 — 통과
+        print(f"    ⚠️ [관계 Self-Reflection] 일부 무효 관계 제외됨. 유효 관계: {len(relations)}개")
+
+    return END
 
 
 builder = StateGraph(ArticleState)
@@ -247,17 +333,26 @@ builder.add_node("extract_relations", extract_relations)
 builder.set_entry_point("check_ai")
 builder.add_conditional_edges("check_ai", route_after_check)
 
-# 자기반성 조건부 엣지 매핑
+# 엔티티 자기반성 루프
 builder.add_conditional_edges(
     "extract_entities",
     validate_entities,
     {
         "extract_entities": "extract_entities",
-        "extract_relations": "extract_relations"
-    }
+        "extract_relations": "extract_relations",
+    },
+)
+
+# 관계 자기반성 루프 (신규)
+builder.add_conditional_edges(
+    "extract_relations",
+    validate_relations,
+    {
+        "extract_relations": "extract_relations",
+        END: END,
+    },
 )
 
-builder.add_edge("extract_relations", END)
 pipeline = builder.compile()
 
 
@@ -377,8 +472,8 @@ def main() -> None:
     global driver
     driver = get_neo4j_driver()
     
-    # 1. 모든 엑셀 파일 로드 후 병합 및 고유 기사만 필터링
-    xlsx_files = sorted(glob.glob("Articles_*.xlsx"))
+    # 1. 모든 엑셀 파일 로드 후 병합 및 고유 기사만 필터링 (루트 및 scrapping 폴더 모두 탐색)
+    xlsx_files = sorted(glob.glob("Articles_*.xlsx") + glob.glob(os.path.join("src", "graphBuilder", "scrapping", "Articles_*.xlsx")))
     if not xlsx_files:
         raise FileNotFoundError("Articles_*.xlsx 파일이 없습니다. finScrapping.py를 먼저 실행하세요.")
     
@@ -421,6 +516,8 @@ def main() -> None:
             relations=[],
             retry_count=0,
             reflection_feedback="",
+            relation_retry_count=0,
+            relation_feedback="",
         )
         out = pipeline.invoke(state)
         if out["is_ai_related"]:
@@ -430,7 +527,14 @@ def main() -> None:
                 for r in out["relations"]:
                     s.execute_write(upsert_relation, r)
                 s.execute_write(upsert_article_and_mentions, row, out["entities"])
-            print(f"  ✅ [{idx + 1}/{len(df)}] 신규 적재완료: {title[:35]}... | 엔티티: {[ent['name'] for ent in out['entities'][:4]]}")
+            rel_cnt = len(out["relations"])
+            ent_cnt = len(out["entities"])
+            # 엔티티가 2개 이상인데 관계가 없으면 경고 표시
+            rel_warn = " ⚠️ 관계=0" if ent_cnt >= 2 and rel_cnt == 0 else ""
+            print(
+                f"  ✅ [{idx + 1}/{len(df)}] 신규 적재완료: {title[:35]}... "
+                f"| 엔티티: {ent_cnt}개 | 관계: {rel_cnt}개{rel_warn}"
+            )
         else:
             print(f"  ⏭️  [{idx + 1}/{len(df)}] AI 비관련 (적재 제외): {title[:35]}...")
     

src/graphBuilder/scrapping/finScrapping.py

@@ -1,7 +1,7 @@
 import re
 import time
 from collections import Counter
-from datetime import datetime
+from datetime import datetime, timedelta
 
 import pandas as pd
 from selenium import webdriver
@@ -9,12 +9,12 @@ from selenium.webdriver.chrome.service import Service
 from selenium.webdriver.common.by import By
 from webdriver_manager.chrome import ChromeDriverManager
 
-# 수집 대상 카테고리
-categories = {
-    "경제": "https://news.naver.com/section/101",
-    "IT/과학": "https://news.naver.com/section/105",
+# 수집 대상 카테고리 sid
+categories_sid = {
+    "경제": "101",
+    "IT/과학": "105",
 }
-NUM_ARTICLES_PER_CATEGORY = 1500
+NUM_ARTICLES_PER_DATE_CAT = 15  # 날짜별/카테고리별 목표 수집량 (7일 * 2개 카테고리 * 15 = 최대 210건 링크 파싱)
 
 # AI 핀테크 키워드 (FinNode 프로젝트 전용)
 FINTECH_AI_KEYWORDS = [
@@ -32,57 +32,61 @@ service = Service(ChromeDriverManager().install())
 options = webdriver.ChromeOptions()
 options.add_argument("--no-sandbox")
 options.add_argument("--disable-dev-shm-usage")
+options.add_argument("--headless")  # 속도 및 안정성 극대화를 위해 headless 모드 활성화
 driver = webdriver.Chrome(service=service, options=options)
 print("[INIT] ✅ 브라우저 실행 완료")
 
 
-def get_article_links(driver, category_url, num_articles):
-    print(f"  [LINK] 페이지 이동: {category_url}")
-    driver.get(category_url)
-    time.sleep(3)
-    print(f"  [LINK] 로드 완료 (title: {driver.title})")
+def get_article_links(driver, sid: str, target_date: str, num_articles: int) -> list[str]:
+    article_links: list[str] = []
+    # 20개씩 끊어서 페이지별 직접 로드하여 속도를 10배 이상 향상시킵니다
+    max_pages = (num_articles // 20) + 1
 
-    print("  [LINK] 더 많은 기사를 불러오기 위해 스크롤 및 '기사 더보기' 버튼을 클릭합니다...")
-    for _ in range(150):  # 최대 150회 스크롤/클릭 시도
-        driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
-        time.sleep(1.0)
-        try:
-            more_btn = driver.find_element(By.CSS_SELECTOR, ".section_more_inner")
-            if more_btn.is_displayed():
-                driver.execute_script("arguments[0].click();", more_btn)
-                time.sleep(1.5)
-        except:
-            pass
-
-    article_links = []
     selectors = [
+        ".list_body a",
+        "ul.type06_headline a",
+        "ul.type06 a",
         "a.sa_text_title",
-        "a.sa_text_lede",
-        "a.sa_text_strong",
         ".sa_text a",
-        ".cluster_text_headline a",
-        ".cluster_text_lede a",
     ]
 
-    for selector in selectors:
-        elements = driver.find_elements(By.CSS_SELECTOR, selector)
-        print(f"  [LINK] 셀렉터 '{selector}' -> {len(elements)}개 발견")
-        for element in elements:
-            url = element.get_attribute("href")
-            if (
-                url
-                and "news.naver.com" in url
-                and "/article/" in url
-                and "/comment/" not in url
-                and url not in article_links
-            ):
-                article_links.append(url)
-                if len(article_links) >= num_articles:
-                    break
-        if len(article_links) >= num_articles:
+    for page in range(1, max_pages + 1):
+        page_url = f"https://news.naver.com/main/list.naver?mode=LSD&mid=sec&sid1={sid}&date={target_date}&page={page}"
+        print(f"  [LINK] 페이지 이동 (Page {page}): {page_url}")
+        try:
+            driver.get(page_url)
+            time.sleep(1.5)
+        except Exception as e:
+            print(f"    [LINK] ⚠️ 페이지 로드 오류 (스킵): {e}")
+            continue
+
+        found_in_page = 0
+        for selector in selectors:
+            elements = driver.find_elements(By.CSS_SELECTOR, selector)
+            for element in elements:
+                try:
+                    url = element.get_attribute("href")
+                    if (
+                        url
+                        and "news.naver.com" in url
+                        and "/article/" in url
+                        and "/comment/" not in url
+                        and url not in article_links
+                    ):
+                        article_links.append(url)
+                        found_in_page += 1
+                        if len(article_links) >= num_articles:
+                            break
+                except Exception:
+                    continue
+            if len(article_links) >= num_articles:
+                break
+
+        print(f"    -> Page {page}에서 {found_in_page}개 기사 링크 확보 (누적: {len(article_links)}개)")
+        if len(article_links) >= num_articles or found_in_page == 0:
             break
 
-    print(f"  [LINK] ✅ 총 {len(article_links)}개 링크 확보\n")
+    print(f"  [LINK] ✅ {target_date} 일자 총 {len(article_links)}개 링크 확보\n")
     return article_links[:num_articles]
 
 
@@ -165,50 +169,69 @@ def parse_article_detail(driver, article_url, category):
 all_articles = []
 category_stats = {}
 
-for category_name, category_url in categories.items():
+# 오늘부터 7일 전까지의 날짜 리스트 생성
+target_dates = [(datetime.now() - timedelta(days=i)).strftime("%Y%m%d") for i in range(7)]
+
+print(f"[CRAWL] 📅 대상 수집 날짜 (7일): {target_dates}")
+
+for target_date in target_dates:
     print(f"\n{'=' * 60}")
-    print(f"[CRAWL] [{category_name}] 카테고리 수집 시작")
+    print(f"[CRAWL] 📅 {target_date} 일자 수집 시작")
     print(f"{'=' * 60}")
 
-    article_links = get_article_links(driver, category_url, NUM_ARTICLES_PER_CATEGORY)
-
-    cat_ok, cat_fail = 0, 0
-    for idx, article_url in enumerate(article_links, 1):
-        print(f"  [PARSE] ({idx}/{len(article_links)}) {article_url[:70]}...")
-        article_data = parse_article_detail(driver, article_url, category_name)
-
-        if article_data["title"] and article_data["content"]:
-            all_articles.append(article_data)
-            cat_ok += 1
-            print(f"    ✅ {article_data['title'][:40]}...")
-            print(f"       언론사: {article_data['source']} | 날짜: {article_data['published_date']}")
-        else:
-            cat_fail += 1
-            missing = [
-                x
-                for x, v in [
-                    ("제목", article_data["title"]),
-                    ("본문", article_data["content"]),
+    for category_name, sid in categories_sid.items():
+        print(f"\n  [CRAWL] [{category_name} - {target_date}] 카테고리 수집 시작")
+        
+        # 날짜별/카테고리별 목표 수집량
+        article_links = get_article_links(driver, sid, target_date, NUM_ARTICLES_PER_DATE_CAT)
+
+        cat_key = f"{category_name}_{target_date}"
+        cat_ok, cat_fail = 0, 0
+        
+        for idx, article_url in enumerate(article_links, 1):
+            print(f"    [PARSE] ({idx}/{len(article_links)}) {article_url[:70]}...")
+            article_data = parse_article_detail(driver, article_url, category_name)
+
+            if article_data["title"] and article_data["content"]:
+                # 만약 파싱된 published_date가 비었거나 이상하다면 target_date 기반으로 날짜 형식 설정
+                if not article_data["published_date"] or "202" not in article_data["published_date"]:
+                    formatted_date = f"{target_date[:4]}-{target_date[4:6]}-{target_date[6:]} 09:00"
+                    article_data["published_date"] = formatted_date
+                
+                all_articles.append(article_data)
+                cat_ok += 1
+                print(f"      ✅ {article_data['title'][:40]}...")
+                print(f"         언론사: {article_data['source']} | 날짜: {article_data['published_date']}")
+            else:
+                cat_fail += 1
+                missing = [
+                    x
+                    for x, v in [
+                        ("제목", article_data["title"]),
+                        ("본문", article_data["content"]),
+                    ]
+                    if not v
                 ]
-                if not v
-            ]
-            print(f"    ❌ 파싱실패 ({', '.join(missing)} 없음)")
-        time.sleep(0.5)
+                print(f"      ❌ 파싱실패 ({', '.join(missing)} 없음)")
+            time.sleep(0.5)
 
-    category_stats[category_name] = {"ok": cat_ok, "fail": cat_fail}
-    print(f"\n  [CRAWL] [{category_name}] 완료: 성공 {cat_ok}개 / 실패 {cat_fail}개")
+        category_stats[cat_key] = {"ok": cat_ok, "fail": cat_fail}
+        print(f"\n    [CRAWL] [{category_name} - {target_date}] 완료: 성공 {cat_ok}개 / 실패 {cat_fail}개")
 
 driver.quit()
 print("\n[DONE] 브라우저 종료")
 print(f"\n{'=' * 60}")
-print("[SUMMARY] 수집 결과 요약")
+print("[SUMMARY] 수집 결과 Summary")
 print(f"{'=' * 60}")
-for cat, s in category_stats.items():
-    print(f"  {cat}: 성공 {s['ok']}건 / 실패 {s['fail']}건")
-print(f"  전체 수집: {len(all_articles)}건")
+total_ok = 0
+total_fail = 0
+for cat_key, s in category_stats.items():
+    print(f"  {cat_key}: 성공 {s['ok']}건 / 실패 {s['fail']}건")
+    total_ok += s['ok']
+    total_fail += s['fail']
+print(f"  전체 수집: 성공 {total_ok}건 / 실패 {total_fail}건")
 
 df_all = pd.DataFrame(all_articles)
-df_all
 
 
 # ── 2단계: AI 핀테크 키워드 필터링 ──
@@ -238,7 +261,11 @@ for kw in FINTECH_AI_KEYWORDS:
 df_filtered
 
 # ── 3단계: 저장 ──
-output_filename = f"Articles_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+import os
+
+output_dir = os.path.join("src", "graphBuilder", "scrapping")
+os.makedirs(output_dir, exist_ok=True)
+output_filename = os.path.join(output_dir, f"Articles_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx")
 df_filtered.to_excel(output_filename, index=False, engine="openpyxl")
 print(f"[SAVE] ✅ 저장 완료: {output_filename}")
 print(f"[SAVE]    - AI 핀테크 기사: {len(df_filtered)}건")

tests/smoke_test_rag.py

@@ -51,6 +51,7 @@ def check_graph_structure():
     print("📊 [사전 점검] Neo4j 그래프 구성 현황")
     print("=" * 60)
 
+    # ── 노드/기본 관계 수 점검 ──────────────────────────────────────────────
     queries = {
         "Article (기사)":        "MATCH (n:Article) RETURN count(n) as cnt",
         "AICompany (기업)":      "MATCH (n:AICompany) RETURN count(n) as cnt",
@@ -72,13 +73,56 @@ def check_graph_structure():
                 all_ok = False
             print(f"  {status}  {label}: {cnt}개")
 
+    # ── 엔티티 간 직접 관계 연결성 심층 점검 ───────────────────────────────
+    print()
+    print("  [엔티티 간 직접 관계 연결성 점검]")
+    entity_rel_types = ["DEVELOPS", "INVESTS_IN", "PARTNERS_WITH", "APPLIES", "USED_IN", "RELATED_TO"]
+    total_entity_rels = 0
+    with driver.session() as s:
+        for rel_type in entity_rel_types:
+            cnt = s.run(
+                f"MATCH ()-[r:{rel_type}]->() RETURN count(r) as cnt"
+            ).single()["cnt"]
+            total_entity_rels += cnt
+            status = "✅" if cnt > 0 else "⚠️"
+            print(f"    {status} {rel_type}: {cnt}개")
+
+        # 고립 노드(관계가 전혀 없는 Content 제외) 비율 점검
+        isolated = s.run(
+            "MATCH (n) WHERE NOT (n)--() AND NOT n:Content RETURN count(n) as cnt"
+        ).single()["cnt"]
+        total_nodes = s.run(
+            "MATCH (n) WHERE NOT n:Content RETURN count(n) as cnt"
+        ).single()["cnt"]
+
+    isolation_rate = (isolated / total_nodes * 100) if total_nodes > 0 else 0
+    iso_status = "✅" if isolation_rate < 20 else "⚠️ 고립 노드 과다"
+    print(f"\n    {iso_status} 고립 노드(Content 제외): {isolated}개 / 전체: {total_nodes}개 ({isolation_rate:.1f}%)")
+    print(f"    엔티티 간 직접 관계 합계: {total_entity_rels}개")
+
+    # 엔티티 간 관계가 전혀 없으면 실패 처리
+    if total_entity_rels == 0:
+        print("\n  ⛔ 엔티티 간 직접 관계(DEVELOPS/APPLIES 등)가 0개입니다. finGraph.py 재실행 필요.")
+        all_ok = False
+
+    # 최소 임계값: 기사 10건당 직접 관계 5개 이상 권고
+    with driver.session() as s:
+        article_cnt = s.run("MATCH (n:Article) RETURN count(n) as cnt").single()["cnt"]
+    if article_cnt > 0:
+        rels_per_article = total_entity_rels / article_cnt
+        threshold_ok = rels_per_article >= 3.0
+        t_status = "✅" if threshold_ok else "⚠️ 관계 밀도 부족"
+        print(f"    {t_status} 기사당 평균 엔티티 관계: {rels_per_article:.1f}개 (권고: 3.0개 이상)")
+        if not threshold_ok:
+            all_ok = False
+
     driver.close()
     print()
     if not all_ok:
-        print("⛔ 일부 노드/관계가 비어있습니다. finGraph.py 실행으로 그래프를 먼저 채워주세요.\n")
+        print("⛔ 일부 노드/관계가 비어있거나 연결성이 부족합니다. finGraph.py 실행으로 그래프를 채워주세요.\n")
         sys.exit(1)
     else:
-        print("✅ 그래프 구성 정상 — RAG 테스트를 시작합니다.\n")
+        print("✅ 그래프 구성 및 연결성 정상 — RAG 테스트를 시작합니다.\n")
 
 
 # ── 1. GraphRAG 응답 품질 검증 ───────────────────────────────────────────────