auto-coder 0.1.222__py3-none-any.whl → 0.1.224__py3-none-any.whl

{auto_coder-0.1.222.dist-info → auto_coder-0.1.224.dist-info}/METADATA

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

{auto_coder-0.1.222.dist-info → auto_coder-0.1.224.dist-info}/RECORD

@@ -1,14 +1,16 @@
 autocoder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autocoder/auto_coder.py,sha256=BQvCwOc-4XgOtpwQWHCTvcx97XEejdwRordyrCYSf0s,43554
+autocoder/auto_coder.py,sha256=Y6PqkMBr2ySUZkpik0XQxBNPA-QSwfn1-c2X7FZzU8g,44514
 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=WV7j5JUiQge0x4-B7Hp5-pSAFXLbvLpzQMcCovbauIM,6276
+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=x98afu7PCzYtf2545tIdJP13tI3lixFJg4sSSFtRjeM,95346
+autocoder/chat_auto_coder.py,sha256=kg2EwnM_uow4GuJJTpqQFZlWKEHfvJqRrq8VDiU422M,96173
 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=tEdfS6Yw3kxd6NglROcL14L5i85YA9bN5_7H9HyePxA,24
+autocoder/version.py,sha256=pM0K3Dh7ms0MYZItkrZfi3XRUP5_QdzhzyMOVUBuG8w,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=jwjsx9qT_5fJmdlbNt3I5UiDtDKcdeLqQ8s_Tw_sT0U,11492
+autocoder/common/__init__.py,sha256=eKIjHf7oyERJxIkySycm9ZjLQcsS2s6zgy9xHFgJKy0,11534
 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=xXDatBOkjV78jsgG1eF8pcMFC0glTm1poesjd_Q6kSw,9169
+autocoder/common/command_completer.py,sha256=sqCA4RkNJr8kkzUmsdMHz1oW5YRqb8Q_2oTq2D6GHlg,9194
 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
@@ -46,9 +48,10 @@ autocoder/common/git_utils.py,sha256=btK45sxvfm4tX3fBRNUPRZoGQuZuOEQrWSAwLy1yoLw
 autocoder/common/image_to_page.py,sha256=O0cNO_vHHUP-fP4GXiVojShmNqkPnZXeIyiY1MRLpKg,13936
 autocoder/common/interpreter.py,sha256=62-dIakOunYB4yjmX8SHC0Gdy2h8NtxdgbpdqRZJ5vk,2833
 autocoder/common/llm_rerank.py,sha256=FbvtCzaR661Mt2wn0qsuiEL1Y3puD6jeIJS4zg_e7Bs,3260
-autocoder/common/mcp_hub.py,sha256=9BqNWjVG8polG-bG8sXIqze-ZzzNJxg2OjfOqgxeM3U,14174
-autocoder/common/mcp_server.py,sha256=tZfjUjBvEp8gaEusD2SaH5Mh0FdbP2MpnyqAWuSgrwo,12652
+autocoder/common/mcp_hub.py,sha256=2ZyJv3Aiv4Y97UHut49oYhIFcu7ICR-mptDEBSgT3uE,14234
+autocoder/common/mcp_server.py,sha256=QCFa-15kx7rbNsinwdGFFX2y47pww0fVdI-ldKFSSWI,12267
 autocoder/common/mcp_tools.py,sha256=KsLvRrB6pvmebqd-lDaSH6IBJR0AIxWRE-dtCEG_w9k,12485
+autocoder/common/memory_manager.py,sha256=2ZjYG7BPyvbYalZBF6AM_G5e10Qkw_zrqtD4Zd7GSsQ,3663
 autocoder/common/recall_validation.py,sha256=Avt9Q9dX3kG6Pf2zsdlOHmsjd-OeSj7U1PFBDp_Cve0,1700
 autocoder/common/screenshots.py,sha256=_gA-z1HxGjPShBrtgkdideq58MG6rqFB2qMUJKjrycs,3769
 autocoder/common/search.py,sha256=245iPFgWhMldoUK3CqCP89ltaxZiNPK73evoG6Fp1h8,16518
@@ -122,9 +125,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.222.dist-info/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-auto_coder-0.1.222.dist-info/METADATA,sha256=T3YPAkMEoTSY8J8xgPi-f-Rn_szn6-A4wJhbQfn5Gvs,2615
-auto_coder-0.1.222.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-auto_coder-0.1.222.dist-info/entry_points.txt,sha256=0nzHtHH4pNcM7xq4EBA2toS28Qelrvcbrr59GqD_0Ak,350
-auto_coder-0.1.222.dist-info/top_level.txt,sha256=Jqc0_uJSw2GwoFQAa9iJxYns-2mWla-9ok_Y3Gcznjk,10
-auto_coder-0.1.222.dist-info/RECORD,,
+auto_coder-0.1.224.dist-info/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+auto_coder-0.1.224.dist-info/METADATA,sha256=SYaMyXGePmPYllfXaO9OJeGxrXQXyGBP1REPYottO6A,2615
+auto_coder-0.1.224.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+auto_coder-0.1.224.dist-info/entry_points.txt,sha256=0nzHtHH4pNcM7xq4EBA2toS28Qelrvcbrr59GqD_0Ak,350
+auto_coder-0.1.224.dist-info/top_level.txt,sha256=Jqc0_uJSw2GwoFQAa9iJxYns-2mWla-9ok_Y3Gcznjk,10
+auto_coder-0.1.224.dist-info/RECORD,,

autocoder/auto_coder.py

@@ -40,6 +40,7 @@ from rich.panel import Panel
 from rich.markdown import Markdown
 from rich.live import Live
 from autocoder.auto_coder_lang import get_message
+from autocoder.common.memory_manager import save_to_memory_file
 
 console = Console()
 
@@ -792,7 +793,7 @@ def main(input_args: Optional[List[str]] = None):
                     pre_conversations.append(
                         {
                             "role": "user",
-                            "content": f"下面是一些文档和源码，如果用户的问题和他们相关，请参考他们：\n <files>\n{file_content}</files>",
+                            "content": f"请阅读下面的代码和文档：\n\n <files>\n{file_content}\n</files>",
                         },
                     )
                     pre_conversations.append(
@@ -819,7 +820,7 @@ def main(input_args: Optional[List[str]] = None):
                 pre_conversations.append(
                     {
                         "role": "user",
-                        "content": f"下面是一些文档和源码，如果用户的问题和他们相关，请参考他们：\n <files>{s}</files>",
+                        "content": f"请阅读下面的代码和文档：\n\n <files>\n{s}\n</files>",
                     }
                 )
                 pre_conversations.append(
@@ -827,7 +828,7 @@ def main(input_args: Optional[List[str]] = None):
                 source_count += 1
 
             loaded_conversations = pre_conversations + \
-                chat_history["ask_conversation"]
+                chat_history["ask_conversation"]              
 
             if args.human_as_model:
                 console = Console()
@@ -836,12 +837,10 @@ def main(input_args: Optional[List[str]] = None):
                 def chat_with_human_as_model(
                     source_codes, pre_conversations, last_conversation
                 ):
-                    """
-                    <files>
-                    {% if source_codes %}
+                    """                    
+                    {% if source_codes %}                    
                     {{ source_codes }}
-                    {% endif %}
-                    </files>
+                    {% endif %}                    
 
                     {% if pre_conversations %}
                     下面是我们之间的历史对话，假设我是A，你是B。
@@ -853,7 +852,7 @@ def main(input_args: Optional[List[str]] = None):
                     {% endif %}
 
 
-                    参考上面的文件以及对话，回答用户的问题。
+                    参考上面的文件以及历史对话，回答用户的问题。
                     用户的问题: {{ last_conversation.content }}
                     """
 
@@ -942,9 +941,14 @@ def main(input_args: Optional[List[str]] = None):
                     ),
                 )
 
+                if "save" in args.action:
+                    save_to_memory_file(ask_conversation=chat_history["ask_conversation"],
+                                        query=args.query,
+                                        response=result)
+                    print("Saved to your memory")
                 return {}
 
-            if args.action == "rag":
+            if "rag" in args.action:
                 args.enable_rag_search = True
                 args.enable_rag_context = False
                 rag = RAGFactory.get_rag(llm=chat_llm, args=args, path="")
@@ -952,7 +956,7 @@ def main(input_args: Optional[List[str]] = None):
                     conversations=[{"role": "user", "content": args.query}])[0]                                                
                 v = ([item, None] for item in response)
                 
-            elif args.action == "mcp": 
+            elif "mcp" in args.action: 
                 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(
@@ -1027,6 +1031,19 @@ def main(input_args: Optional[List[str]] = None):
             with open(memory_file, "w") as f:
                 json.dump(chat_history, f, ensure_ascii=False)
 
+            if "copy" in args.action:
+                #copy assistant_response to clipboard
+                import pyperclip
+                try:
+                    pyperclip.copy(assistant_response)    
+                except:
+                    print("pyperclip not installed or clipboard is not supported, instruction will not be copied to clipboard.")
+
+            if "save" in args.action:
+                save_to_memory_file(ask_conversation=chat_history["ask_conversation"],
+                                    query=args.query,
+                                    response=assistant_response)  
+                print("Saved to your memory")                      
             return
 
         else:

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": True
+                    })}],
+                    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

@@ -48,6 +48,7 @@ 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
+from autocoder.common.memory_manager import get_global_memory_file_paths 
 
 
 class SymbolItem(BaseModel):
@@ -1657,6 +1658,9 @@ def commit(query: str):
                 return_paths=True
             )
 
+            if conf.get("enable_global_memory", "true") in ["true", "True",True]:
+                yaml_config["urls"] += get_global_memory_file_paths()
+
             # 临时保存yaml文件，然后读取yaml文件，转换为args
             temp_yaml = os.path.join("actions", f"{uuid.uuid4()}.yml")
             try:
@@ -1740,11 +1744,14 @@ def coding(query: str):
             converted_value = convert_config_value(key, value)
             if converted_value is not None:
                 yaml_config[key] = converted_value
-
+        
         yaml_config["urls"] = current_files + get_llm_friendly_package_docs(
             return_paths=True
         )
 
+        if conf.get("enable_global_memory", "true") in ["true", "True",True]:
+            yaml_config["urls"] += get_global_memory_file_paths()
+        
         # handle image
         v = Image.convert_image_paths_from(query)
         yaml_config["query"] = v
@@ -1794,7 +1801,7 @@ def coding(query: str):
 
             yaml_config[
                 "context"
-            ] += f"下面是我们的历史对话，参考我们的历史对话从而更好的理解需求和修改代码。\n\n<history>\n"
+            ] += f"下面是我们的历史对话，参考我们的历史对话从而更好的理解需求和修改代码: \n\n<history>\n"
             for conv in conversations:
                 if conv["role"] == "user":
                     yaml_config["context"] += f"用户: {conv['content']}\n"
@@ -1855,6 +1862,9 @@ def chat(query: str):
         return_paths=True
     )
 
+    if conf.get("enable_global_memory", "true") in ["true", "True",True]:
+        current_files += get_global_memory_file_paths()
+
     yaml_config["urls"] = current_files
 
     if "emb_model" in conf:
@@ -1864,14 +1874,24 @@ def chat(query: str):
     if is_new:
         query = query.replace("/new", "", 1).strip()
 
+    yaml_config["action"] = []    
+
     if "/mcp " in query:
-        yaml_config["action"] = "mcp"
+        yaml_config["action"].append("mcp")
         query = query.replace("/mcp ", "", 1).strip()
 
     if "/rag " in query:
-        yaml_config["action"] = "rag"
+        yaml_config["action"].append("rag")
         query = query.replace("/rag ", "", 1).strip()
 
+    if "/copy" in query:
+        yaml_config["action"].append("copy")
+        query = query.replace("/copy", "", 1).strip()   
+
+    if "/save" in query:
+        yaml_config["action"].append("save")
+        query = query.replace("/save", "", 1).strip()        
+
     is_review = query.strip().startswith("/review")
     if is_review:
         query = query.replace("/review", "", 1).strip()

autocoder/common/__init__.py

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

autocoder/common/command_completer.py

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

autocoder/common/mcp_hub.py

@@ -192,7 +192,7 @@ class McpHub:
                      "PATH": os.environ.get("PATH", "")},
             )
 
-            # Create transport using context manager
+            # Create transport using context manager            
             transport_manager = stdio_client(server_params)
             transport = await transport_manager.__aenter__()
             try:
@@ -204,9 +204,9 @@ class McpHub:
                 self.connections[name] = connection
 
                 # Update server status and fetch capabilities
-                server.status = "connected"
-                server.tools = await self._fetch_tools(name)
-                server.resources = await self._fetch_resources(name)
+                server.status = "connected"                
+                server.tools = await self._fetch_tools(name)                
+                server.resources = await self._fetch_resources(name)                
                 server.resource_templates = await self._fetch_resource_templates(name)
 
             except Exception as e:

autocoder/common/mcp_server.py

@@ -128,6 +128,35 @@ class McpServer:
         self._task = self._loop.create_task(self._process_request())
         self._loop.run_forever()
 
+    def _install_python_package(self, package_name: str) -> None:
+        """Install a Python package using pip"""
+        try:
+            import importlib
+            importlib.import_module(package_name.replace("-", "_"))
+        except ImportError:
+            import subprocess
+            try:
+                subprocess.run([sys.executable, "-m", "pip", "install", package_name], check=True)
+            except subprocess.CalledProcessError:
+                print(f"\n\033[93mFailed to automatically install {package_name}. Please manually install it using:\n")
+                print(f"    pip install {package_name}\n")
+                print(f"We have already updated the server configuration in ~/.autocoder/mcp/settings.json.\n")
+                print(f"After installation, you can restart the auto-coder.chat using the server.\033[0m\n")
+
+    def _install_node_package(self, package_name: str) -> None:
+        """Install a Node.js package using npm"""
+        import subprocess
+        try:
+            subprocess.run(["npx", package_name, "--version"], check=True)
+        except:
+            try:
+                subprocess.run(["npm", "install", "-y", "-g", package_name], check=True)
+            except subprocess.CalledProcessError:
+                print(f"\n\033[93mFailed to automatically install {package_name}. Please manually install it using:\n")
+                print(f"    npm install -g {package_name}\n")
+                print(f"We have already updated the server configuration in ~/.autocoder/mcp/settings.json.\n")
+                print(f"After installation, you can restart the auto-coder.chat using the server.\033[0m\n")
+
     async def _install_server(self, request: McpInstallRequest, hub: McpHub) -> McpResponse:
         """Install an MCP server with module dependency check"""
         name = ""
@@ -143,6 +172,12 @@ class McpServer:
                 # 取第一个server 配置
                 config = list(raw_config.values())[0]
                 name = list(raw_config.keys())[0]
+                if name.startswith("@") or config["command"] in ["npx","npm"]:
+                    for item in config["args"]:
+                        if name in item:
+                            self._install_node_package(item)                    
+                else:
+                    self._install_python_package(name)
             except json.JSONDecodeError:
                 name = server_name_or_config.strip()
                 if name not in MCP_BUILD_IN_SERVERS:
@@ -151,26 +186,7 @@ class McpServer:
                     for s in external_servers:
                         if s.name == name:
                             if s.runtime == "python":
-                                # Check if module exists
-                                try:
-                                    import importlib
-                                    importlib.import_module(
-                                        name.replace("-", "_"))
-                                except ImportError:
-                                    # Install missing module
-                                    import subprocess
-                                    try:
-                                        subprocess.run(
-                                            [sys.executable, "-m", "pip", "install", name], check=True)
-                                    except subprocess.CalledProcessError:
-                                        print(
-                                            f"\n\033[93mFailed to automatically install {name}. Please manually install it using:\n")
-                                        print(f"    pip install {name}\n")
-                                        print(
-                                            f"We have already updated the server configuration in ~/.autocoder/mcp/settings.json.\n")
-                                        print(
-                                            f"After installation, you can restart the auto-coder.chat using the server.\033[0m\n")
-
+                                self._install_python_package(name)
                                 config = {
                                     "command": "python",
                                     "args": [
@@ -178,28 +194,12 @@ class McpServer:
                                     ],
                                 }
                             elif s.runtime == "node":
-                                # Check if package exists
-                                try:
-                                    subprocess.run(
-                                        ["npx", name, "--version"], check=True)
-                                except:
-                                    # Install missing package
-                                    try:
-                                        subprocess.run(
-                                            ["npm", "install", "-y", "-g", name], check=True)
-                                    except subprocess.CalledProcessError:
-                                        print(
-                                            f"\n\033[93mFailed to automatically install {name}. Please manually install it using:\n")
-                                        print(f"    npm install -g {name}\n")
-                                        print(
-                                            f"We have already updated the server configuration in ~/.autocoder/mcp/settings.json.\n")
-                                        print(
-                                            f"After installation, you can restart the auto-coder.chat using the server.\033[0m\n")
-
+                                self._install_node_package(name)
                                 config = {
                                     "command": "npx",
                                     "args": [
                                         "-y",
+                                        "-g",
                                         name
                                     ]
                                 }

autocoder/common/memory_manager.py

@@ -0,0 +1,112 @@
+import os
+import json
+import time
+from typing import List, Dict, Optional, Any
+from pydantic import BaseModel
+from datetime import datetime
+
+class MemoryItem(BaseModel):
+    content: Any
+    role: str
+
+class MemoryEntry(BaseModel):
+    timestamp: datetime
+    conversation: List[MemoryItem]
+
+
+def save_to_memory_file(ask_conversation,query:str,response:str):
+    # Save to memory file                
+    memory_dir = os.path.join(os.path.expanduser("~"), ".auto-coder", "memory")
+    os.makedirs(memory_dir, exist_ok=True)
+    memory_file = os.path.join(memory_dir, "memory.json")
+    
+    # Read existing memory or create new
+    if os.path.exists(memory_file):
+        with open(memory_file, 'r') as f:
+            try:
+                memory_data = json.load(f)
+            except json.JSONDecodeError:
+                memory_data = {}
+    else:
+        memory_data = {}
+    
+    # Add new conversation
+    current_time = str(int(time.time()))
+    memory_data[current_time] = [
+        {"content": ask_conversation, "role": "background"},
+        {"content": query, "role": "user"},
+        {"content": response, "role": "assistant"}
+    ]
+    
+    # Save memory
+    with open(memory_file, 'w') as f:
+        json.dump(memory_data, f, ensure_ascii=False, indent=2)   
+
+def load_from_memory_file() -> List[MemoryEntry]:
+    """Load memory data from file and return as list of MemoryEntry objects"""
+    memory_dir = os.path.join(os.path.expanduser("~"), ".auto-coder", "memory")
+    memory_file = os.path.join(memory_dir, "memory.json")
+    
+    if not os.path.exists(memory_file):
+        return []
+    
+    with open(memory_file, 'r') as f:
+        try:
+            memory_data = json.load(f)
+        except json.JSONDecodeError:
+            return []
+    
+    entries = []
+    for timestamp_str, conversation in memory_data.items():
+        try:
+            timestamp = datetime.fromtimestamp(int(timestamp_str))
+            memory_items = [MemoryItem(**item) for item in conversation]
+            entries.append(MemoryEntry(
+                timestamp=timestamp,
+                conversation=memory_items
+            ))
+        except (ValueError, TypeError):
+            continue
+            
+    # Sort entries by timestamp (oldest first)
+    entries.sort(key=lambda x: x.timestamp)
+    
+    return entries
+
+def get_global_memory_file_paths() -> List[str]:
+    """Get global memory and generate temporary files in ~/.auto-coder/memory/.tmp
+    
+    Returns:
+        List[str]: List of file paths for the generated temporary files
+    """
+    entries = load_from_memory_file()
+    memory_dir = os.path.join(os.path.expanduser("~"), ".auto-coder", "memory")
+    tmp_dir = os.path.join(memory_dir, ".tmp")
+    os.makedirs(tmp_dir, exist_ok=True)
+    
+    file_paths = []
+    
+    for entry in entries:
+        # Find assistant responses
+        assistant_contents = [
+            item.content for item in entry.conversation 
+            if item.role == "assistant"
+        ]
+        
+        if assistant_contents:
+            timestamp_str = str(int(entry.timestamp.timestamp()))
+            content = "\n".join(assistant_contents)
+            file_path = os.path.join(tmp_dir, os.path.join("memory",f"{timestamp_str}.txt"))
+            
+            # Create parent directory if it doesn't exist
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+            
+            # Only write file if it doesn't exist
+            if not os.path.exists(file_path):
+                with open(file_path, "w", encoding="utf-8") as f:
+                    f.write(content)
+            
+            file_paths.append(file_path)
+    
+    return file_paths
+

autocoder/version.py

@@ -1 +1 @@
-__version__ = "0.1.222"
+__version__ = "0.1.224"