auto-coder 0.1.221__py3-none-any.whl → 0.1.223__py3-none-any.whl

{auto_coder-0.1.221.dist-info → auto_coder-0.1.223.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.221
+Version: 0.1.223
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence

{auto_coder-0.1.221.dist-info → auto_coder-0.1.223.dist-info}/RECORD

@@ -1,14 +1,16 @@
 autocoder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autocoder/auto_coder.py,sha256=uDYc3fZOtdVBKS-bBaBKlAhriIypvf3MRnv8xERuhLo,42354
+autocoder/auto_coder.py,sha256=BQvCwOc-4XgOtpwQWHCTvcx97XEejdwRordyrCYSf0s,43554
 autocoder/auto_coder_lang.py,sha256=Rtupq6N3_HT7JRhDKdgCBcwRaiAnyCOR_Gsp4jUomrI,3229
 autocoder/auto_coder_rag.py,sha256=illKgzP2bv-Tq50ujsofJnOHdI4pzr0ALtfR8NHHWdQ,22351
+autocoder/auto_coder_rag_client_mcp.py,sha256=WU8WzwuRbJE-W_r94S8PYKOQ32FEv2WPJzCgZII7dBc,6277
+autocoder/auto_coder_rag_mcp.py,sha256=-RrjNwFaS2e5v8XDIrKR-zlUNUE8UBaeOtojffBrvJo,8521
 autocoder/auto_coder_server.py,sha256=XU9b4SBH7zjPPXaTWWHV4_zJm-XYa6njuLQaplYJH_c,20290
 autocoder/benchmark.py,sha256=Ypomkdzd1T3GE6dRICY3Hj547dZ6_inqJbBJIp5QMco,4423
-autocoder/chat_auto_coder.py,sha256=NTCWQKBQJluEhay5NGoTl5tdv00Zmu8oFioCjCpJCd8,94294
+autocoder/chat_auto_coder.py,sha256=x98afu7PCzYtf2545tIdJP13tI3lixFJg4sSSFtRjeM,95346
 autocoder/chat_auto_coder_lang.py,sha256=ReWukXKVvuzVvpbYk5O9kc1ev7XNmAv3DnuQhmpLmnc,8717
 autocoder/command_args.py,sha256=9aYJ-AmPxP1sQh6ciw04FWHjSn31f2W9afXFwo8wgx4,30441
 autocoder/lang.py,sha256=U6AjVV8Rs1uLyjFCZ8sT6WWuNUxMBqkXXIOs4S120uk,14511
-autocoder/version.py,sha256=F7GjYmyw7k9LVz_Kphmow9gIQSXHNBbfNLD31KwhxuU,24
+autocoder/version.py,sha256=hA-WuAig1V69eSYfuZJjxnT6-tLr5fGDFA1I86siMMg,24
 autocoder/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autocoder/agent/auto_demand_organizer.py,sha256=NWSAEsEk94vT3lGjfo25kKLMwYdPcpy9e-i21txPasQ,6942
 autocoder/agent/auto_filegroup.py,sha256=CW7bqp0FW1GIEMnl-blyAc2UGT7O9Mom0q66ITz1ckM,6635
@@ -21,7 +23,7 @@ autocoder/agent/project_reader.py,sha256=tWLaPoLw1gI6kO_NzivQj28KbobU2ceOLuppHMb
 autocoder/chat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autocoder/common/JupyterClient.py,sha256=O-wi6pXeAEYhAY24kDa0BINrLYvKS6rKyWe98pDClS0,2816
 autocoder/common/ShellClient.py,sha256=fM1q8t_XMSbLBl2zkCNC2J9xuyKN3eXzGm6hHhqL2WY,2286
-autocoder/common/__init__.py,sha256=Itx7HWrrMEMszf4hpUZ7YhIGbpWQVtJjQOWOEqRsa-Q,11458
+autocoder/common/__init__.py,sha256=jwjsx9qT_5fJmdlbNt3I5UiDtDKcdeLqQ8s_Tw_sT0U,11492
 autocoder/common/anything2images.py,sha256=0ILBbWzY02M-CiWB-vzuomb_J1hVdxRcenAfIrAXq9M,25283
 autocoder/common/anything2img.py,sha256=4TREa-sOA-iargieUy7MpyCYVUE-9Mmq0wJtwomPqnE,7662
 autocoder/common/audio.py,sha256=Kn9nWKQddWnUrAz0a_ZUgjcu4VUU_IcZBigT7n3N3qc,7439
@@ -38,7 +40,7 @@ autocoder/common/code_auto_merge_diff.py,sha256=5SI6ggklJ0QDHvsS0cpNXFuIkFRQxp1i
 autocoder/common/code_auto_merge_editblock.py,sha256=l6yEiZqXyIlUNIIPXvkHOnLCIInXR78TzSjF-jtJkkg,17035
 autocoder/common/code_auto_merge_strict_diff.py,sha256=ABYOTDUQYA4Bn4BwT1Rw812y49cHW3UH_JSpM9uJ6ig,9399
 autocoder/common/code_modification_ranker.py,sha256=DFlbwgdg8GK47zVcvfZSzkyniEKmTVLTOWejjcVIgaw,5121
-autocoder/common/command_completer.py,sha256=10nNnazkzZwya-jScPLlhpCBR2oYsOiVfwofqGvIUEM,9145
+autocoder/common/command_completer.py,sha256=xXDatBOkjV78jsgG1eF8pcMFC0glTm1poesjd_Q6kSw,9169
 autocoder/common/command_generator.py,sha256=v4LmU7sO-P7jEZIXCWHUC6P-vT7AvBi_x_PTwCqBAE8,1323
 autocoder/common/command_templates.py,sha256=3G-pCNbL6iHbnkG6v1JZpbIK3Mc9d373_RYGmCcDPMY,8548
 autocoder/common/const.py,sha256=eTjhjh4Aj4CUzviJ81jaf3Y5cwqsLATySn2wJxaS6RQ,2911
@@ -57,7 +59,7 @@ autocoder/common/sys_prompt.py,sha256=JlexfjZt554faqbgkCmzOJqYUzDHfbnxly5ugFfHfE
 autocoder/common/text.py,sha256=KGRQq314GHBmY4MWG8ossRoQi1_DTotvhxchpn78c-k,1003
 autocoder/common/types.py,sha256=oQKPE1TG0O7DQQLaBSMp6CP3Bbvg0K8elFdidlV52Lg,631
 autocoder/common/mcp_servers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autocoder/common/mcp_servers/mcp_server_perplexity.py,sha256=OV_orQ6NsVnLxGt0SkVt9wsxu-nw7gOuwa4hgtdastI,5546
+autocoder/common/mcp_servers/mcp_server_perplexity.py,sha256=jz0LkCgZcqKkNdLZ9swNOu9Besoba4JOyHDedoZnWHo,5546
 autocoder/data/tokenizer.json,sha256=QfO_ZCE9qMAS2L0IcaWKH99wRj6PCPEQ3bsQgvUp9mk,4607451
 autocoder/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autocoder/db/store.py,sha256=tFT66bP2ZKIqZip-uhLkHRSLaaOAUUDZfozJwcqix3c,1908
@@ -78,7 +80,7 @@ autocoder/rag/api_server.py,sha256=dRbhAZVRAOlZ64Cnxf4_rKb4iJwHnrWS9Zr67IVORw0,7
 autocoder/rag/doc_filter.py,sha256=B99Qcy3tcNLuSz2kWbpgfBj2_Igme91zWKOJ2Niq2UY,6652
 autocoder/rag/document_retriever.py,sha256=5oThtxukGuRFF96o3pHKsk306a8diXbhgSrbqyU2BvM,8894
 autocoder/rag/llm_wrapper.py,sha256=sbDxCANiZyWb_ocqNgqu2oy3c2t8orPNRGleEs-Uwl8,2649
-autocoder/rag/long_context_rag.py,sha256=jEhil33y2ryAF393zKdUhrk_QEHUlZ30gZcvPH0Z3MY,25074
+autocoder/rag/long_context_rag.py,sha256=F-ulTwSZ9ogIGL9jTXDUnI44zStH02EjrztZgRkW9-g,25246
 autocoder/rag/rag_config.py,sha256=8LwFcTd8OJWWwi1_WY4IzjqgtT6RyE2j4PjxS5cCTDE,802
 autocoder/rag/rag_entry.py,sha256=6TKtErZ0Us9XSV6HgRKXA6yR3SiZGPHpynOKSaR1wgE,2463
 autocoder/rag/raw_rag.py,sha256=yS2Ur6kG0IRjhCj2_VonwxjY_xls_E62jO5Gz5j2nqE,2952
@@ -122,9 +124,9 @@ autocoder/utils/request_event_queue.py,sha256=r3lo5qGsB1dIjzVQ05dnr0z_9Z3zOkBdP1
 autocoder/utils/request_queue.py,sha256=nwp6PMtgTCiuwJI24p8OLNZjUiprC-TsefQrhMI-yPE,3889
 autocoder/utils/rest.py,sha256=HawagAap3wMIDROGhY1730zSZrJR_EycODAA5qOj83c,8807
 autocoder/utils/tests.py,sha256=BqphrwyycGAvs-5mhH8pKtMZdObwhFtJ5MC_ZAOiLq8,1340
-auto_coder-0.1.221.dist-info/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-auto_coder-0.1.221.dist-info/METADATA,sha256=uh1Y5Uy-muRqdjAjSNHtQ9O8aKLAYFLiATKrVPRLPrs,2615
-auto_coder-0.1.221.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-auto_coder-0.1.221.dist-info/entry_points.txt,sha256=0nzHtHH4pNcM7xq4EBA2toS28Qelrvcbrr59GqD_0Ak,350
-auto_coder-0.1.221.dist-info/top_level.txt,sha256=Jqc0_uJSw2GwoFQAa9iJxYns-2mWla-9ok_Y3Gcznjk,10
-auto_coder-0.1.221.dist-info/RECORD,,
+auto_coder-0.1.223.dist-info/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+auto_coder-0.1.223.dist-info/METADATA,sha256=wma3ZSYec0V5FYUoLcbVDuWamEWG0ClOEoOInJkGnCQ,2615
+auto_coder-0.1.223.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+auto_coder-0.1.223.dist-info/entry_points.txt,sha256=0nzHtHH4pNcM7xq4EBA2toS28Qelrvcbrr59GqD_0Ak,350
+auto_coder-0.1.223.dist-info/top_level.txt,sha256=Jqc0_uJSw2GwoFQAa9iJxYns-2mWla-9ok_Y3Gcznjk,10
+auto_coder-0.1.223.dist-info/RECORD,,

autocoder/auto_coder.py

@@ -577,6 +577,9 @@ def main(input_args: Optional[List[str]] = None):
             with Live(
                 Panel("", title="Response", border_style="green", expand=False),
                 refresh_per_second=4,
+                auto_refresh=True,
+                vertical_overflow="visible",
+                console=Console(force_terminal=True, color_system="auto", height=None)
             ) as live:
                 live.update(
                     Panel(
@@ -689,6 +692,9 @@ def main(input_args: Optional[List[str]] = None):
             with Live(
                 Panel("", title="Response", border_style="green", expand=False),
                 refresh_per_second=4,
+                auto_refresh=True,
+                vertical_overflow="visible",
+                console=Console(force_terminal=True, color_system="auto", height=None)
             ) as live:
                 live.update(
                     Panel(
@@ -698,8 +704,8 @@ def main(input_args: Optional[List[str]] = None):
                         expand=False,
                     )
                 )
-            return
 
+            return
         elif raw_args.agent_command == "designer":
             from autocoder.agent.designer import SVGDesigner, SDDesigner, LogoDesigner
 
@@ -938,11 +944,24 @@ def main(input_args: Optional[List[str]] = None):
 
                 return {}
 
-            if args.enable_rag_search or args.enable_rag_context:
+            if args.action == "rag":
+                args.enable_rag_search = True
+                args.enable_rag_context = False
                 rag = RAGFactory.get_rag(llm=chat_llm, args=args, path="")
                 response = rag.stream_chat_oai(
-                    conversations=loaded_conversations)[0]
+                    conversations=[{"role": "user", "content": args.query}])[0]                                                
                 v = ([item, None] for item in response)
+                
+            elif args.action == "mcp": 
+                from autocoder.common.mcp_server import get_mcp_server, McpRequest, McpInstallRequest, McpRemoveRequest, McpListRequest, McpListRunningRequest, McpRefreshRequest                               
+                mcp_server = get_mcp_server()
+                response = mcp_server.send_request(
+                    McpRequest(
+                        query=args.query,
+                        model=args.inference_model or args.model
+                    )
+                )
+                v = [[response.result,None]]
             else:
                 v = chat_llm.stream_chat_oai(
                     conversations=loaded_conversations, delta_mode=True
@@ -953,10 +972,11 @@ def main(input_args: Optional[List[str]] = None):
 
             try:
                 with Live(
-                    Panel("", title="Response"),
+                    Panel("", title="Response", border_style="green", expand=False),
                     refresh_per_second=4,
                     auto_refresh=True,
-                    vertical_overflow="visible"
+                    vertical_overflow="visible",
+                    console=Console(force_terminal=True, color_system="auto", height=None)
                 ) as live:
                     for res in v:
                         markdown_content += res[0]
@@ -977,7 +997,7 @@ def main(input_args: Optional[List[str]] = None):
                                 expand=False,
                             )
                         )
-                live.update(
+                    live.update(
                             Panel(
                                 Markdown(markdown_content),
                                 title="Response",
@@ -999,7 +1019,7 @@ def main(input_args: Optional[List[str]] = None):
                         value=StreamValue(value=[""]), status=RequestOption.COMPLETED
                     ),
                 )
-
+            
             chat_history["ask_conversation"].append(
                 {"role": "assistant", "content": assistant_response}
             )

autocoder/auto_coder_rag_client_mcp.py

@@ -0,0 +1,170 @@
+from typing import Any, List, Dict, Generator, Optional
+import asyncio
+import httpx
+import argparse
+from mcp.server.models import InitializationOptions
+import mcp.types as types
+from mcp.server import NotificationOptions, Server
+import mcp.server.stdio
+from autocoder.common import AutoCoderArgs
+from byzerllm import ByzerLLM
+from autocoder.lang import lang_desc
+import locale
+import pkg_resources
+from openai import OpenAI
+
+class AutoCoderRAGClientMCP:
+    def __init__(self, llm: ByzerLLM, args: AutoCoderArgs):
+        self.llm = llm
+        self.args = args
+        
+        if not args.rag_url:
+            raise ValueError("rag_url is required for RAG client mode")
+            
+        if not args.rag_url.startswith("http://"):
+            args.rag_url = f"http://{args.rag_url}"
+            
+        if not args.rag_url.endswith("/v1"):
+            args.rag_url = args.rag_url.rstrip("/") + "/v1"
+            
+        if not args.rag_token:
+            raise ValueError("rag_token is required for RAG client mode")
+            
+        self.client = OpenAI(api_key=args.rag_token, base_url=args.rag_url)
+        
+        self.server = Server("auto_coder_rag_client")
+
+    async def setup_server(self):
+        @self.server.list_tools()
+        async def handle_list_tools() -> List[types.Tool]:
+            return [
+                types.Tool(
+                    name="rag-search",
+                    description="Search documents using RAG",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "query": {
+                                "type": "string",
+                                "description": "Search query",
+                            },
+                        },
+                        "required": ["query"],
+                    },
+                ),
+                types.Tool(
+                    name="rag-chat",
+                    description="Chat with documents using RAG",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "query": {
+                                "type": "string",
+                                "description": "Chat query",
+                            },
+                        },
+                        "required": ["query"],
+                    },
+                ),
+            ]
+
+        @self.server.call_tool()
+        async def handle_call_tool(
+            name: str, arguments: Dict[str, Any] | None
+        ) -> List[types.TextContent | types.ImageContent | types.EmbeddedResource]:
+            if not arguments:
+                raise ValueError("Missing arguments")
+
+            if name == "rag-search":
+                query = arguments.get("query")
+                if not query:
+                    raise ValueError("Missing query parameter")
+
+                response = self.client.chat.completions.create(
+                    messages=[{"role": "user", "content": json.dumps({
+                        "query": query,
+                        "only_contexts": False
+                    })}],
+                    model=self.args.model,
+                    max_tokens=self.args.rag_params_max_tokens,
+                )
+                result = response.choices[0].message.content
+                
+                return [
+                    types.TextContent(
+                        type="text",
+                        text=f"Search results for '{query}':\n\n{result}"
+                    )
+                ]
+
+            elif name == "rag-chat":
+                query = arguments.get("query")
+                if not query:
+                    raise ValueError("Missing query parameter")
+
+                response = self.client.chat.completions.create(
+                    messages=[{"role": "user", "content": query}],
+                    model=self.args.model,
+                    stream=True,
+                    max_tokens=self.args.rag_params_max_tokens
+                )
+                
+                full_response = ""
+                for chunk in response:
+                    if chunk.choices[0].delta.content is not None:
+                        full_response += chunk.choices[0].delta.content
+                
+                return [
+                    types.TextContent(
+                        type="text",
+                        text=f"Chat response for '{query}':\n\n{full_response}"
+                    )
+                ]
+
+            else:
+                raise ValueError(f"Unknown tool: {name}")
+
+    async def run(self):
+        async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
+            await self.server.run(
+                read_stream,
+                write_stream,
+                InitializationOptions(
+                    server_name="auto_coder_rag_client",
+                    server_version="0.1.0",
+                    capabilities=self.server.get_capabilities(
+                        notification_options=NotificationOptions(),
+                        experimental_capabilities={},
+                    ),
+                ),
+            )
+
+def parse_args(input_args: Optional[List[str]] = None) -> AutoCoderArgs:    
+    system_lang, _ = locale.getdefaultlocale()
+    lang = "zh" if system_lang and system_lang.startswith("zh") else "en"
+    desc = lang_desc[lang]
+    
+    parser = argparse.ArgumentParser(description="Auto Coder RAG Client MCP Server")
+    parser.add_argument("--rag_url", required=True, help="RAG server URL")
+    parser.add_argument("--rag_token", required=True, help="RAG server token")
+    parser.add_argument("--model", default="deepseek_chat", help=desc["model"])
+    parser.add_argument("--rag_params_max_tokens", type=int, default=4096, help="Max tokens for RAG response")
+    
+    args = parser.parse_args(input_args)
+    return AutoCoderArgs(**vars(args))
+
+async def main():
+    # Parse command line arguments
+    args = parse_args()
+    
+    # Initialize LLM
+    llm = ByzerLLM()
+    llm.setup_default_model_name(args.model)
+    
+    # Initialize and run server
+    server = AutoCoderRAGClientMCP(llm=llm, args=args)
+    await server.setup_server()
+    await server.run()
+
+if __name__ == "__main__":
+    asyncio.run(main())

autocoder/auto_coder_rag_mcp.py

@@ -0,0 +1,193 @@
+from typing import Any, List, Dict, Generator, Optional
+import asyncio
+import httpx
+import argparse
+from mcp.server.models import InitializationOptions
+import mcp.types as types
+from mcp.server import NotificationOptions, Server
+import mcp.server.stdio
+from autocoder.rag.long_context_rag import LongContextRAG
+from autocoder.common import AutoCoderArgs
+from byzerllm import ByzerLLM
+from autocoder.lang import lang_desc
+import locale
+import pkg_resources
+
+class AutoCoderRAGMCP:
+    def __init__(self, llm: ByzerLLM, args: AutoCoderArgs):
+        self.llm = llm
+        self.args = args
+        self.rag = LongContextRAG(
+            llm=llm,
+            args=args,
+            path=args.source_dir,
+            tokenizer_path=args.tokenizer_path
+        )
+        self.server = Server("auto_coder_rag")
+
+    async def setup_server(self):
+        @self.server.list_tools()
+        async def handle_list_tools() -> List[types.Tool]:
+            return [
+                types.Tool(
+                    name="rag-search",
+                    description="Search documents using RAG",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "query": {
+                                "type": "string",
+                                "description": "Search query",
+                            },
+                        },
+                        "required": ["query"],
+                    },
+                ),
+                types.Tool(
+                    name="rag-chat",
+                    description="Chat with documents using RAG",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "query": {
+                                "type": "string",
+                                "description": "Chat query",
+                            },
+                        },
+                        "required": ["query"],
+                    },
+                ),
+            ]
+
+        @self.server.call_tool()
+        async def handle_call_tool(
+            name: str, arguments: Dict[str, Any] | None
+        ) -> List[types.TextContent | types.ImageContent | types.EmbeddedResource]:
+            if not arguments:
+                raise ValueError("Missing arguments")
+
+            if name == "rag-search":
+                query = arguments.get("query")
+                if not query:
+                    raise ValueError("Missing query parameter")
+
+                results = self.rag.search(query)
+                return [
+                    types.TextContent(
+                        type="text",
+                        text=f"Search results for '{query}':\n\n" + 
+                        "\n".join([f"- {result.module_name}: {result.source_code[:200]}..." 
+                                 for result in results])
+                    )
+                ]
+
+            elif name == "rag-chat":
+                query = arguments.get("query")
+                if not query:
+                    raise ValueError("Missing query parameter")
+
+                response, _ = self.rag.stream_chat_oai(
+                    conversations=[{"role": "user", "content": query}]
+                )
+                full_response = "".join([chunk for chunk in response])
+                
+                return [
+                    types.TextContent(
+                        type="text",
+                        text=f"Chat response for '{query}':\n\n{full_response}"
+                    )
+                ]
+
+            else:
+                raise ValueError(f"Unknown tool: {name}")
+
+    async def run(self):
+        async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
+            await self.server.run(
+                read_stream,
+                write_stream,
+                InitializationOptions(
+                    server_name="auto_coder_rag",
+                    server_version="0.1.0",
+                    capabilities=self.server.get_capabilities(
+                        notification_options=NotificationOptions(),
+                        experimental_capabilities={},
+                    ),
+                ),
+            )
+
+def parse_args(input_args: Optional[List[str]] = None) -> AutoCoderArgs:
+    try:
+        tokenizer_path = pkg_resources.resource_filename(
+            "autocoder", "data/tokenizer.json"
+        )
+    except FileNotFoundError:
+        tokenizer_path = None
+
+    system_lang, _ = locale.getdefaultlocale()
+    lang = "zh" if system_lang and system_lang.startswith("zh") else "en"
+    desc = lang_desc[lang]
+    
+    parser = argparse.ArgumentParser(description="Auto Coder RAG MCP Server")
+    parser.add_argument("--source_dir", default=".", help="Source directory path")
+    parser.add_argument("--tokenizer_path", default=tokenizer_path, help="Path to tokenizer file")
+    parser.add_argument("--model", default="deepseek_chat", help=desc["model"])
+    parser.add_argument("--index_model", default="", help=desc["index_model"])
+    parser.add_argument("--emb_model", default="", help=desc["emb_model"])
+    parser.add_argument("--ray_address", default="auto", help=desc["ray_address"])
+    parser.add_argument("--required_exts", default="", help=desc["doc_build_parse_required_exts"])
+    parser.add_argument("--rag_doc_filter_relevance", type=int, default=5, help="Relevance score threshold for document filtering")
+    parser.add_argument("--rag_context_window_limit", type=int, default=56000, help="Context window limit for RAG")
+    parser.add_argument("--full_text_ratio", type=float, default=0.7, help="Ratio of full text area in context window")
+    parser.add_argument("--segment_ratio", type=float, default=0.2, help="Ratio of segment area in context window")
+    parser.add_argument("--index_filter_workers", type=int, default=5, help="Number of workers for document filtering")
+    parser.add_argument("--index_filter_file_num", type=int, default=3, help="Maximum number of files to filter")
+    parser.add_argument("--host", default="", help="Server host address")
+    parser.add_argument("--port", type=int, default=8000, help="Server port")
+    parser.add_argument("--monitor_mode", action="store_true", help="Enable document monitoring mode")
+    parser.add_argument("--enable_hybrid_index", action="store_true", help="Enable hybrid index")
+    parser.add_argument("--disable_auto_window", action="store_true", help="Disable automatic window adaptation")
+    parser.add_argument("--disable_segment_reorder", action="store_true", help="Disable segment reordering")
+    parser.add_argument("--disable_inference_enhance", action="store_true", help="Disable inference enhancement")
+    parser.add_argument("--inference_deep_thought", action="store_true", help="Enable deep thought in inference")
+    parser.add_argument("--inference_slow_without_deep_thought", action="store_true", help="Enable slow inference without deep thought")
+    parser.add_argument("--inference_compute_precision", type=int, default=64, help="Inference compute precision")
+    parser.add_argument("--data_cells_max_num", type=int, default=2000, help="Maximum number of data cells to process")
+    parser.add_argument("--recall_model", default="", help="Model used for document recall")
+    parser.add_argument("--chunk_model", default="", help="Model used for document chunking")
+    parser.add_argument("--qa_model", default="", help="Model used for question answering")    
+
+    args = parser.parse_args(input_args)
+    return AutoCoderArgs(**vars(args)),args
+
+async def main():
+    # Parse command line arguments
+    args,raw_rags = parse_args()
+    
+    # Initialize LLM
+    llm = ByzerLLM()
+    llm.setup_default_model_name(args.model)
+    
+    # Setup sub models if specified
+    if raw_rags.recall_model:
+        recall_model = ByzerLLM()
+        recall_model.setup_default_model_name(args.recall_model)
+        llm.setup_sub_client("recall_model", recall_model)
+
+    if raw_rags.chunk_model:
+        chunk_model = ByzerLLM()
+        chunk_model.setup_default_model_name(args.chunk_model)
+        llm.setup_sub_client("chunk_model", chunk_model)
+
+    if raw_rags.qa_model:
+        qa_model = ByzerLLM()
+        qa_model.setup_default_model_name(args.qa_model)
+        llm.setup_sub_client("qa_model", qa_model)
+
+    # Initialize and run server
+    server = AutoCoderRAGMCP(llm=llm, args=args)
+    await server.setup_server()
+    await server.run()
+
+if __name__ == "__main__":
+    asyncio.run(main())

autocoder/chat_auto_coder.py

@@ -38,6 +38,7 @@ from rich.table import Table
 from rich.live import Live
 from rich.text import Text
 from rich.live import Live
+from rich.markdown import Markdown
 from byzerllm.utils.nontext import Image
 import git
 from autocoder.common import git_utils
@@ -46,6 +47,7 @@ from autocoder.utils import operate_config_api
 from autocoder.agent.auto_guess_query import AutoGuessQuery
 from autocoder.common.mcp_server import get_mcp_server, McpRequest, McpInstallRequest, McpRemoveRequest, McpListRequest, McpListRunningRequest, McpRefreshRequest
 import byzerllm
+from byzerllm.utils import format_str_jinja2
 
 
 class SymbolItem(BaseModel):
@@ -1499,11 +1501,32 @@ def mcp(query: str):
             model=args.inference_model or args.model
         )
     )
-
+    console = Console()
     if response.error:
-        print(f"Error from MCP server: {response.error}")
+        console.print(Panel(
+            f"Error from MCP server: {response.error}",
+            title="Error",
+            border_style="red"
+        ))
     else:
-        print(response.result)
+        # Save conversation
+        mcp_dir = os.path.join(".auto-coder", "mcp", "conversations")
+        os.makedirs(mcp_dir, exist_ok=True)
+        timestamp = str(int(time.time()))
+        file_path = os.path.join(mcp_dir, f"{timestamp}.md")
+        
+        # Format response as markdown
+        markdown_content = f"# MCP Response\n\n{response.result}"
+        
+        # Save to file
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(markdown_content)
+            
+        # Print with markdown formatting
+        console.print(Panel(
+            Markdown(markdown_content),            
+            border_style="green"
+        ))
 
 
 def code_next(query: str):
@@ -1837,10 +1860,18 @@ def chat(query: str):
     if "emb_model" in conf:
         yaml_config["emb_model"] = conf["emb_model"]
 
-    is_new = query.strip().startswith("/new")
+    is_new = "/new" in query
     if is_new:
         query = query.replace("/new", "", 1).strip()
 
+    if "/mcp " in query:
+        yaml_config["action"] = "mcp"
+        query = query.replace("/mcp ", "", 1).strip()
+
+    if "/rag " in query:
+        yaml_config["action"] = "rag"
+        query = query.replace("/rag ", "", 1).strip()
+
     is_review = query.strip().startswith("/review")
     if is_review:
         query = query.replace("/review", "", 1).strip()

autocoder/common/__init__.py

@@ -348,5 +348,7 @@ class AutoCoderArgs(pydantic.BaseModel):
     data_cells_max_num: Optional[int] = 2000
     generate_times_same_model: Optional[int] = 1
 
+    action: Optional[str] = None
+
     class Config:
         protected_namespaces = ()

autocoder/common/command_completer.py

@@ -13,7 +13,7 @@ COMMANDS = {
         "/sd": {},
     },
     "/coding": {"/apply": {}, "/next": {}},
-    "/chat": {"/new": {}, "/review": {}, "/no_context": {}},
+    "/chat": {"/new": {}, "/mcp": {}, "/rag": {}, "/review": {}, "/no_context": {}},
     "/mcp": {
         "/add": "",         
         "/remove": "",

autocoder/common/mcp_servers/mcp_server_perplexity.py

@@ -51,11 +51,11 @@ async def handle_list_tools() -> list[types.Tool]:
                         "type": "string",
                         "description": "The name of the model that will complete your prompt.",
                         "enum": [
-                            "llama-3.1-sonar-small-128k-online",
+                            # "llama-3.1-sonar-small-128k-online",
                             # Commenting out larger models,which have higher risks of timing out,
                             # until Claude Desktop can handle long-running tasks effectively.
                             # "llama-3.1-sonar-large-128k-online",
-                            # "llama-3.1-sonar-huge-128k-online",
+                            "llama-3.1-sonar-huge-128k-online",
                         ],
                     },
                     "messages": {

autocoder/rag/long_context_rag.py

@@ -104,6 +104,8 @@ class LongContextRAG:
                 raise ValueError(
                     "You are in client mode, please provide the RAG token. e.g. rag_token: your_token_here"
                 )
+            if not args.rag_url.endswith("/v1"):
+                args.rag_url = args.rag_url.rstrip("/") + "/v1"
             self.client = OpenAI(api_key=args.rag_token, base_url=args.rag_url)
         else:
             self.client = None
@@ -340,6 +342,7 @@ class LongContextRAG:
                 model=model,
                 messages=conversations,
                 stream=True,
+                max_tokens=self.args.rag_params_max_tokens
             )
 
             def response_generator():

autocoder/version.py

@@ -1 +1 @@
-__version__ = "0.1.221"
+__version__ = "0.1.223"