Update app.py

app.py

@@ -3,139 +3,144 @@
 import gradio as gr
 import os
 import subprocess
-from langchain_mistralai.chat_models import ChatMistralAI
-from langchain_core.messages import HumanMessage, AIMessage
-from langchain.agents import AgentExecutor, create_tool_calling_agent
-from langchain_core.prompts import ChatPromptTemplate
-from langchain.tools import tool
+from mistralai.client import MistralClient
+from mistralai.models.chat_completion import ChatMessage
 
-# --- 1. 환경 설정 및 LLM 초기화 ---
-API_KEY = os.environ.get("MISTRAL_API_KEY", None)
-llm = None
+# --- 1. 환경 설정 및 클라이언트 초기화 ---
+API_KEY = os.environ.get("MISTRAL_API_KEY")
+CLIENT = None
 if API_KEY:
     try:
-        llm = ChatMistralAI(model="codestral-latest", temperature=0, api_key=API_KEY, streaming=True)
+        CLIENT = MistralClient(api_key=API_KEY)
+        print("Mistral API Client initialized successfully.")
     except Exception as e:
-        print(f"Failed to initialize LLM: {e}")
+        print(f"Error initializing Mistral Client: {e}")
 else:
     print("FATAL: MISTRAL_API_KEY is not set in Space Secrets.")
 
-# --- 2. 핵심 도구(Tools) 정의 ---
-# LangChain 에이전트가 내부적으로 사용할 @tool 데코레이터
-@tool
+# --- 2. 핵심 기능 함수 (MCP 도구로 사용될 함수들) ---
 def generate_c_code(description: str) -> str:
-    """Generates complete, compilable C code based on a natural language description. Use this when the user wants to create new code."""
-    if not llm: return "Error: LLM not initialized."
-    code_generation_prompt = f"""You are a world-class C programming expert.
-Generate a single, complete, and compilable C code file based on this request: '{description}'.
-The code must be clean, efficient, and include necessary headers.
-ONLY output the raw C code within a single C code block. No explanations, no extra text."""
-    response = llm.invoke([HumanMessage(content=code_generation_prompt)])
-    code = response.content
+    """Generates C code based on a natural language description."""
+    if not CLIENT: return "Error: Mistral API key not configured."
+    
+    prompt = f"""You are a C programming expert. Your task is to generate a complete, compilable C code based on the user's request.
+The code should be clean, efficient, and well-commented.
+Please only output the raw C code inside a single C code block and nothing else.
+User's request: {description}"""
+    
+    messages = [ChatMessage(role="user", content=prompt)]
+    response = CLIENT.chat(model="codestral-latest", messages=messages)
+    code = response.choices[0].message.content
+    
     if "```c" in code:
         code = code.split("```c")[1].split("```")[0].strip()
+    elif "```" in code:
+        code = code.split("```")[1].split("```")[0].strip()
+        
     return code
 
-@tool
 def compile_and_run_c_code(code: str) -> str:
-    """Compiles and runs a given C code snippet and returns its output or any errors. Use this to verify or test code."""
+    """Compiles and runs a given C code snippet and returns its output or any errors."""
     try:
         with open("main.c", "w", encoding='utf-8') as f:
             f.write(code)
+            
         compile_proc = subprocess.run(
             ["gcc", "main.c", "-o", "main.out", "-lm", "-w"],
             capture_output=True, text=True, timeout=15
         )
         if compile_proc.returncode != 0:
             return f"--- COMPILATION FAILED ---\n{compile_proc.stderr}"
+            
         run_proc = subprocess.run(
             ["./main.out"], capture_output=True, text=True, timeout=15
         )
         if run_proc.returncode != 0:
             return f"--- RUNTIME ERROR ---\n{run_proc.stderr}"
+            
         output = run_proc.stdout
         if not output.strip():
             return "--- EXECUTION SUCCEEDED ---\n(No output was produced)"
         return f"--- EXECUTION SUCCEEDED ---\n{output}"
+        
     except subprocess.TimeoutExpired:
         return "--- ERROR ---\nProcess timed out. Check for infinite loops."
     except Exception as e:
         return f"--- SYSTEM ERROR ---\nAn unexpected error occurred: {str(e)}"
 
-@tool
-def refactor_or_analyze_c_code(code: str, request: str) -> str:
-    """Analyzes, refactors, or explains a given C code based on a user's specific request. Use this for code improvement or understanding."""
-    if not llm: return "Error: LLM not initialized."
-    analysis_prompt = f"""You are a senior C code reviewer. Analyze the following C code based on the user's request.
-Provide a clear, concise, and helpful response. If refactoring, provide the complete improved code in a C code block.
-User's Request: '{request}'
-C Code to Analyze:
-```c
-{code}
-```"""
-    response = llm.invoke([HumanMessage(content=analysis_prompt)])
-    return response.content
-
-# --- 3. MCP 도구 API 생성 ---
-# 각 도구를 gr.Interface를 사용해 API로 만듭니다. 이것이 외부 MCP 클라이언트에 노출됩니다.
-generate_api = gr.Interface(fn=generate_c_code, inputs="text", outputs="code", title="C Code Generator", description="Generates C code from a description.")
-compile_api = gr.Interface(fn=compile_and_run_c_code, inputs="code", outputs="text", title="C Code Compiler & Runner", description="Compiles and runs C code.")
-refactor_api = gr.Interface(fn=refactor_or_analyze_c_code, inputs=["code", "text"], outputs="markdown", title="C Code Refactor & Analyzer", description="Refactors or analyzes C code.")
-
-# --- 4. LangChain 에이전트 설정 ---
-tools = [generate_c_code, compile_and_run_c_code, refactor_or_analyze_c_code]
-agent_executor = None
-if llm:
-    agent_prompt = ChatPromptTemplate.from_messages([
-        ("system", "You are a powerful C-language assistant agent. You can generate, compile, and analyze C code. Think step-by-step and use your tools to fulfill the user's request. If you generate code, you should almost always offer to compile and run it for the user as the next step."),
-        ("placeholder", "{chat_history}"),
-        ("human", "{input}"),
-        ("placeholder", "{agent_scratchpad}"),
-    ])
-    agent = create_tool_calling_agent(llm, tools, agent_prompt)
-    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)
-
-def agent_chat(user_input, history):
-    if agent_executor is None:
-        yield "Error: MISTRAL_API_KEY is not configured. Please set it in the Space secrets."
+# --- 3. Gradio 챗봇 로직 (Agent 역할) ---
+def agent_chat(message, history):
+    if not CLIENT:
+        yield "MISTRAL_API_KEY를 Space Secrets에 설정해주세요."
         return
-    chat_history = []
+
+    # 대화 기록을 포함하여 LLM에게 전달
+    history_messages = []
     for human, ai in history:
-        chat_history.append(HumanMessage(content=human))
-        chat_history.append(AIMessage(content=ai))
-    response_stream = agent_executor.stream({"input": user_input, "chat_history": chat_history})
-    full_response = ""
-    for chunk in response_stream:
-        if "output" in chunk:
-            full_response += chunk["output"]
-            yield full_response
+        history_messages.append(ChatMessage(role="user", content=human))
+        history_messages.append(ChatMessage(role="assistant", content=ai))
+    
+    history_messages.append(ChatMessage(role="user", content=message))
+    
+    # 시스템 프롬프트: 에이전트의 역할을 정의
+    system_prompt = """You are a helpful C programming assistant.
+    - If the user asks to generate code, call the `generate_c_code` function by outputting a JSON object like: `{"tool": "generate_c_code", "description": "user's request"}`.
+    - If the user asks to compile or run code, find the last C code block in the conversation and call the `compile_and_run_c_code` function by outputting a JSON object like: `{"tool": "compile_and_run_c_code", "code": "the c code"}`.
+    - For anything else, answer as a helpful assistant."""
+    
+    # 이 예제에서는 LLM이 도구를 호출하는 대신, 간단한 키워드 기반 라우팅으로 안정성을 확보합니다.
+    # 복잡한 에이전트 로직을 제거하여 라이브러리 충돌을 원천 차단합니다.
+    lower_message = message.lower()
+    
+    if "compile" in lower_message or "run" in lower_message or "실행" in lower_message:
+        # 히스토리에서 코드 찾기
+        code_to_run = ""
+        for h_user, h_ai in reversed(history):
+            if "```c" in h_ai:
+                code_to_run = h_ai.split("```c")[1].split("```")[0].strip()
+                break
+        if not code_to_run:
+            yield "컴파일할 코드를 찾을 수 없습니다. 먼저 코드를 생성해주세요."
+            return
+        
+        yield f"코드를 컴파일하고 실행합니다...\n\n```c\n{code_to_run}\n```"
+        result = compile_and_run_c_code(code_to_run)
+        yield result
+            
+    elif "generate" in lower_message or "create" in lower_message or "만들어줘" in lower_message or "짜줘" in lower_message:
+        yield "C 코드를 생성하는 중..."
+        generated_code = generate_c_code(message)
+        yield f"코드가 생성되었습니다. 컴파일하거나 실행하려면 'run this code'라고 입력하세요.\n\n```c\n{generated_code}\n```"
+        
+    else:
+        # 일반 대화
+        response = CLIENT.chat(model="codestral-latest", messages=history_messages)
+        yield response.choices[0].message.content
+
 
-# --- 5. Gradio UI/UX 디자인 ---
-with gr.Blocks(theme=gr.themes.Monochrome(), css=".gradio-container{max-width: 800px !important; margin: auto;}") as demo:
+# --- 4. Gradio UI 구성 ---
+with gr.Blocks(theme=gr.themes.Soft(), css=".gradio-container{max-width: 800px !important; margin: auto;}") as demo:
     gr.Markdown("# 🚀 C-Codestral Agent")
     with gr.Tabs():
+        # 메인 챗봇 UI
         with gr.TabItem("🤖 Agent Chat"):
-            chatbot = gr.Chatbot(label="C-Agent", bubble_full_width=False, height=600, avatar_images=(None, "https://huggingface.co/datasets/huggingface/brand-assets/resolve/main/hf-logo-with-title.png"))
-            with gr.Row():
-                txt = gr.Textbox(show_label=False, placeholder="Enter your request and press enter...", container=False, scale=7)
-                submit_btn = gr.Button("Submit", variant="primary", scale=1)
-            txt.submit(agent_chat, [txt, chatbot], chatbot)
-            submit_btn.click(agent_chat, [txt, chatbot], chatbot)
-            txt.submit(lambda: "", None, txt)
-            submit_btn.click(lambda: "", None, txt)
+            chatbot = gr.Chatbot(label="C-Agent", height=600, bubble_full_width=False)
+            msg = gr.Textbox(placeholder="Ask me to generate or run C code...", label="Your Request")
+            msg.submit(agent_chat, [msg, chatbot], chatbot)
+            msg.submit(lambda: "", None, msg) # Clear input after submit
+            
             gr.Examples(
-                ["Generate a C program to calculate the factorial of a number.", "Now, compile and run the code you just created.", "Refactor the factorial code to use recursion instead of a loop."],
-                inputs=txt, label="Example Prompts"
+                ["Generate a C program to calculate the factorial of 10.", "run the code"],
+                inputs=msg
             )
-        # MCP 도구들을 별도의 탭에 API로 노출
+        
+        # MCP 도구 API 탭
         with gr.TabItem("🛠️ MCP Tools API"):
             gr.Markdown("## Available MCP Tools\nThese APIs can be used by any MCP-compliant client.")
             with gr.Accordion("Tool: Generate C Code", open=False):
-                generate_api.render()
+                gr.Interface(fn=generate_c_code, inputs="text", outputs=gr.Code(language="c"), allow_flagging="never")
             with gr.Accordion("Tool: Compile & Run C Code", open=False):
-                compile_api.render()
-            with gr.Accordion("Tool: Refactor & Analyze C Code", open=False):
-                refactor_api.render()
+                gr.Interface(fn=compile_and_run_c_code, inputs=gr.Code(language="c"), outputs="text", allow_flagging="never")
 
 if __name__ == "__main__":
-    demo.queue().launch(debug=True)
+    demo.queue().launch()