app/metacognitive_agent.py

"""
메타인지 에이전트 (Metacognitive Agent)

이 에이전트는 다음과 같은 메타인지 전략을 사용합니다:
1. Planning (계획): 답변 전략 수립
2. Monitoring (감시): 답변 과정 모니터링
3. Evaluation (평가): 답변 품질 평가
4. Revision (수정): 필요시 답변 개선
"""

from typing import List, Dict, Optional
from anthropic import Anthropic
from loguru import logger
import json


class MetaCognitiveAgent:
    """메타인지 능력을 가진 AI 에이전트"""

    def __init__(self, api_key: str):
        """
        Args:
            api_key: Anthropic API 키
        """
        self.client = Anthropic(api_key=api_key)
        self.thinking_history = []
        self.model = "claude-3-5-sonnet-20241022"

        # 메타인지 프롬프트
        self.reflection_prompts = {
            "planning": """
당신은 금융/경제 분야의 전문가입니다. 다음 질문에 답하기 위한 전략을 수립하세요.

질문: {query}

검색된 관련 문서:
{context}

다음 사항을 고려하여 답변 계획을 세우세요:
1. 질문이 요구하는 핵심 정보는 무엇인가?
2. 제공된 문서들이 질문에 답하기에 충분한가?
3. 어떤 정보를 우선적으로 사용해야 하는가?
4. 주의해야 할 점이나 한계는 무엇인가?

계획을 JSON 형식으로 작성하세요:
{{
    "key_information": "질문의 핵심 정보",
    "context_adequacy": "문서의 충분성 (충분/부족/불확실)",
    "strategy": "답변 전략",
    "limitations": "주의사항 및 한계"
}}
""",

            "monitoring": """
현재 생성 중인 답변을 검토하세요.

질문: {query}
현재 답변: {response}

다음을 확인하세요:
1. 답변이 질문에 직접적으로 대답하고 있는가?
2. 제공된 문서의 정보를 정확히 사용하고 있는가?
3. 추론이 논리적으로 타당한가?
4. Hallucination(근거 없는 정보)이 포함되어 있지 않은가?

평가를 JSON 형식으로 작성하세요:
{{
    "relevance": "질문과의 관련성 (높음/중간/낮음)",
    "accuracy": "정확성 (높음/중간/낮음)",
    "logic": "논리성 (타당함/보통/문제있음)",
    "hallucination_risk": "Hallucination 위험도 (낮음/중간/높음)",
    "issues": ["발견된 문제점들"]
}}
""",

            "evaluation": """
최종 답변을 평가하세요.

질문: {query}
답변: {response}
사용된 출처: {sources}

다음 기준으로 평가하세요:
1. 완전성: 질문에 완전히 답했는가?
2. 정확성: 정보가 정확한가?
3. 명확성: 답변이 명확하고 이해하기 쉬운가?
4. 신뢰성: 출처가 명확하고 신뢰할 수 있는가?

평가를 JSON 형식으로 작성하세요:
{{
    "completeness": "완전성 점수 (1-10)",
    "accuracy": "정확성 점수 (1-10)",
    "clarity": "명확성 점수 (1-10)",
    "reliability": "신뢰성 점수 (1-10)",
    "overall_score": "전체 점수 (1-10)",
    "feedback": "개선이 필요한 부분"
}}
""",

            "revision": """
답변을 개선하세요.

원본 답변: {response}
평가 피드백: {feedback}

피드백을 바탕으로 답변을 개선하세요. 특히:
1. 부정확한 정보 수정
2. 불완전한 부분 보완
3. 불명확한 표현 개선
4. 근거 없는 주장 제거

개선된 답변만 제공하세요.
"""
        }

    async def think_and_reflect(
        self,
        query: str,
        context_documents: List[Dict],
        max_iterations: int = 2
    ) -> Dict:
        """
        메타인지 과정을 통한 답변 생성

        Args:
            query: 사용자 질문
            context_documents: 검색된 관련 문서들
            max_iterations: 최대 개선 반복 횟수

        Returns:
            최종 답변 및 메타인지 과정 정보
        """
        self.thinking_history = []

        # 컨텍스트 포맷팅
        context_text = self._format_context(context_documents)

        # 1단계: 계획 수립 (Planning)
        logger.info("1️⃣ Planning: 답변 전략 수립 중...")
        plan = await self._plan(query, context_text)
        self.thinking_history.append({"step": "planning", "content": plan})

        # 2단계: 초기 응답 생성
        logger.info("2️⃣ Generating: 초기 답변 생성 중...")
        initial_response = await self._generate_response(query, context_text, plan)
        self.thinking_history.append({"step": "initial_response", "content": initial_response})

        # 3단계: 모니터링 (Monitoring)
        logger.info("3️⃣ Monitoring: 답변 검토 중...")
        monitoring_result = await self._monitor(query, initial_response)
        self.thinking_history.append({"step": "monitoring", "content": monitoring_result})

        current_response = initial_response

        # 4단계: 반복적 개선
        for iteration in range(max_iterations):
            # 평가 (Evaluation)
            logger.info(f"4️⃣ Evaluation [{iteration + 1}/{max_iterations}]: 답변 평가 중...")
            evaluation = await self._evaluate(
                query,
                current_response,
                [doc.get('source_filename', 'unknown') for doc in context_documents]
            )
            self.thinking_history.append({"step": f"evaluation_{iteration}", "content": evaluation})

            # 평가 점수가 충분히 높으면 종료
            try:
                eval_data = json.loads(evaluation)
                overall_score = float(eval_data.get('overall_score', 0))

                if overall_score >= 8.0:
                    logger.info(f"✅ 충분한 품질 달성 (점수: {overall_score}/10)")
                    break
            except:
                pass

            # 개선 (Revision)
            logger.info(f"5️⃣ Revision [{iteration + 1}/{max_iterations}]: 답변 개선 중...")
            current_response = await self._revise(current_response, evaluation)
            self.thinking_history.append({"step": f"revision_{iteration}", "content": current_response})

        return {
            "query": query,
            "final_response": current_response,
            "thinking_history": self.thinking_history,
            "context_documents": context_documents,
            "iterations": len([h for h in self.thinking_history if "revision" in h["step"]])
        }

    async def _plan(self, query: str, context: str) -> str:
        """계획 수립"""
        prompt = self.reflection_prompts["planning"].format(
            query=query,
            context=context
        )

        message = self.client.messages.create(
            model=self.model,
            max_tokens=1024,
            messages=[{"role": "user", "content": prompt}]
        )

        return message.content[0].text

    async def _generate_response(self, query: str, context: str, plan: str) -> str:
        """초기 응답 생성"""
        prompt = f"""
당신은 금융/경제 분야의 전문가입니다.

답변 계획:
{plan}

질문: {query}

참고 문서:
{context}

위 계획을 바탕으로 질문에 답변하세요. 반드시:
1. 제공된 문서의 정보만 사용하세요
2. 확실하지 않은 정보는 추측하지 마세요
3. 출처를 명확히 밝히세요
4. 한국어로 답변하세요
"""

        message = self.client.messages.create(
            model=self.model,
            max_tokens=2048,
            messages=[{"role": "user", "content": prompt}]
        )

        return message.content[0].text

    async def _monitor(self, query: str, response: str) -> str:
        """답변 모니터링"""
        prompt = self.reflection_prompts["monitoring"].format(
            query=query,
            response=response
        )

        message = self.client.messages.create(
            model=self.model,
            max_tokens=1024,
            messages=[{"role": "user", "content": prompt}]
        )

        return message.content[0].text

    async def _evaluate(self, query: str, response: str, sources: List[str]) -> str:
        """답변 평가"""
        prompt = self.reflection_prompts["evaluation"].format(
            query=query,
            response=response,
            sources=", ".join(sources)
        )

        message = self.client.messages.create(
            model=self.model,
            max_tokens=1024,
            messages=[{"role": "user", "content": prompt}]
        )

        return message.content[0].text

    async def _revise(self, response: str, feedback: str) -> str:
        """답변 개선"""
        prompt = self.reflection_prompts["revision"].format(
            response=response,
            feedback=feedback
        )

        message = self.client.messages.create(
            model=self.model,
            max_tokens=2048,
            messages=[{"role": "user", "content": prompt}]
        )

        return message.content[0].text

    def _format_context(self, documents: List[Dict]) -> str:
        """문서들을 컨텍스트 텍스트로 포맷팅"""
        formatted = []
        for i, doc in enumerate(documents, 1):
            text = doc.get('text', doc.get('document', ''))
            metadata = doc.get('metadata', {})
            source = metadata.get('source_filename', 'Unknown')

            formatted.append(f"[문서 {i}] {source}\n{text}\n")

        return "\n".join(formatted)