auto-coder 0.1.282__tar.gz → 0.1.284__tar.gz

{auto_coder-0.1.282 → auto_coder-0.1.284}/PKG-INFO

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

{auto_coder-0.1.282 → auto_coder-0.1.284}/src/auto_coder.egg-info/PKG-INFO

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

{auto_coder-0.1.282 → auto_coder-0.1.284}/src/auto_coder.egg-info/SOURCES.txt

@@ -121,6 +121,7 @@ src/autocoder/rag/document_retriever.py
 src/autocoder/rag/lang.py
 src/autocoder/rag/llm_wrapper.py
 src/autocoder/rag/long_context_rag.py
+src/autocoder/rag/qa_conversation_strategy.py
 src/autocoder/rag/rag_config.py
 src/autocoder/rag/rag_entry.py
 src/autocoder/rag/raw_rag.py

{auto_coder-0.1.282 → auto_coder-0.1.284}/src/autocoder/common/__init__.py

@@ -295,7 +295,13 @@ class AutoCoderArgs(pydantic.BaseModel):
     rag_type: Optional[str] = "storage"   
     rag_params_max_tokens: Optional[int] = 4096 
     rag_doc_filter_relevance: Optional[int] = 5
-    rag_context_window_limit: Optional[int] = 120000    
+    rag_context_window_limit: Optional[int] = 120000 
+    
+    # 回答用户问题时，使用哪种对话历史策略
+    # single_round: 单轮对话
+    # multi_round: 多轮对话
+    rag_qa_conversation_strategy: Optional[str] = "multi_round"
+
     verify_file_relevance_score: int = 6
     enable_rag_search: Optional[Union[bool, str]] = False
     enable_rag_context: Optional[Union[bool, str]] = False

{auto_coder-0.1.282 → auto_coder-0.1.284}/src/autocoder/rag/lang.py

@@ -13,7 +13,8 @@ MESSAGES = {
         "doc_filter_start": "Document filtering start, total {{total}} documents",
         "doc_filter_progress": "Document filtering progress: {{progress_percent}}% processed {{relevant_count}}/{{total}} documents",
         "doc_filter_error": "Document filtering error: {{error}}",
-        "doc_filter_complete": "Document filtering complete, cost {{total_time}} seconds, found {{relevant_count}} relevant documents"
+        "doc_filter_complete": "Document filtering complete, cost {{total_time}} seconds, found {{relevant_count}} relevant documents",
+        "context_docs_names": "The following are the documents related to the user's question: {{context_docs_names}}",
     },
     "zh": {
         "rag_error_title": "RAG 错误",
@@ -26,7 +27,8 @@ MESSAGES = {
         "doc_filter_start": "开始过滤文档，共 {{total}} 个文档",
         "doc_filter_progress": "文档过滤进度：{{progress_percent}}%，处理了 {{relevant_count}}/{{total}} 个文档",
         "doc_filter_error": "文档过滤错误：{{error}}",
-        "doc_filter_complete": "文档过滤完成，耗时 {{total_time}} 秒，找到 {{relevant_count}} 个相关文档"
+        "doc_filter_complete": "文档过滤完成，耗时 {{total_time}} 秒，找到 {{relevant_count}} 个相关文档",
+        "context_docs_names": "以下是和用户问题相关的文档：{{context_docs_names}}",
     }
 }
 

{auto_coder-0.1.282 → auto_coder-0.1.284}/src/autocoder/rag/long_context_rag.py

@@ -37,6 +37,7 @@ from autocoder.rag.relevant_utils import DocFilterResult
 from pydantic import BaseModel
 from byzerllm.utils.types import SingleOutputMeta
 from autocoder.rag.lang import get_message_with_format_and_newline
+from autocoder.rag.qa_conversation_strategy import get_qa_strategy
 
 try:
     from autocoder_pro.rag.llm_compute import LLMComputeEngine
@@ -173,10 +174,11 @@ class LongContextRAG:
 
         self.token_limit = self.args.rag_context_window_limit or 120000
         retriever_class = self._get_document_retriever_class()
-        
+
         if self.args.enable_hybrid_index and not self.on_ray:
             if self.emb_llm is None:
-                raise ValueError("emb_llm is required for local byzer storage cache")
+                raise ValueError(
+                    "emb_llm is required for local byzer storage cache")
 
         self.document_retriever = retriever_class(
             self.path,
@@ -255,36 +257,7 @@ class LongContextRAG:
         请根据提供的文档内容、用户对话历史以及最后一个问题，提取并总结文档中与问题相关的重要信息。
         如果文档中没有相关信息，请回复"该文档中没有与问题相关的信息"。
         提取的信息尽量保持和原文中的一样，并且只输出这些信息。
-        """
-
-    @byzerllm.prompt()
-    def _answer_question(
-        self, query: str, relevant_docs: List[str]
-    ) -> Generator[str, None, None]:
-        """        
-        文档：
-        <documents>
-        {% for doc in relevant_docs %}
-        {{ doc }}
-        {% endfor %}
-        </documents>
-
-        使用以上文档来回答用户的问题。回答要求：
-
-        1. 严格基于文档内容回答        
-        - 如果文档提供的信息无法回答问题,请明确回复:"抱歉,文档中没有足够的信息来回答这个问题。" 
-        - 不要添加、推测或扩展文档未提及的信息
-
-        2. 格式如 ![image](./path.png) 的 Markdown 图片处理
-        - 根据Markdown 图片前后文本内容推测改图片与问题的相关性，有相关性则在回答中输出该Markdown图片路径
-        - 根据相关图片在文档中的位置，自然融入答复内容,保持上下文连贯
-        - 完整保留原始图片路径,不省略任何部分
-
-        3. 回答格式要求
-        - 使用markdown格式提升可读性
-
-        问题：{{ query }}
-        """
+        """    
 
     def _get_document_retriever_class(self):
         """Get the document retriever class based on configuration."""
@@ -626,10 +599,23 @@ class LongContextRAG:
                 return [json.dumps(final_docs, ensure_ascii=False)], []
 
             if not relevant_docs:
-                return ["没有找到相关的文档来回答这个问题。"], []
+                yield ("没有找到可以回答你问题的相关文档", SingleOutputMeta(input_tokens_count=rag_stat.recall_stat.total_input_tokens + rag_stat.chunk_stat.total_input_tokens,
+                                                            generated_tokens_count=rag_stat.recall_stat.total_generated_tokens +
+                                                            rag_stat.chunk_stat.total_generated_tokens,
+                                                            ))
+                return
 
             context = [doc.source_code.module_name for doc in relevant_docs]
 
+            yield ("", SingleOutputMeta(input_tokens_count=rag_stat.recall_stat.total_input_tokens + rag_stat.chunk_stat.total_input_tokens,
+                                        generated_tokens_count=rag_stat.recall_stat.total_generated_tokens +
+                                        rag_stat.chunk_stat.total_generated_tokens,
+                                        reasoning_content=get_message_with_format_and_newline(
+                                            "context_docs_names",
+                                            context_docs_names=",".join(
+                                                context))
+                                        ))
+
             # 将 FilterDoc 转化为 SourceCode 方便后续的逻辑继续做处理
             relevant_docs = [doc.source_code for doc in relevant_docs]
 
@@ -788,7 +774,7 @@ class LongContextRAG:
                                             tokens=request_tokens
                                         )
                                         ))
-            
+
             yield ("", SingleOutputMeta(input_tokens_count=rag_stat.recall_stat.total_input_tokens + rag_stat.chunk_stat.total_input_tokens,
                                         generated_tokens_count=rag_stat.recall_stat.total_generated_tokens +
                                         rag_stat.chunk_stat.total_generated_tokens,
@@ -830,16 +816,12 @@ class LongContextRAG:
 
                 self._print_rag_stats(rag_stat)
             else:
-                new_conversations = conversations[:-1] + [
-                    {
-                        "role": "user",
-                        "content": self._answer_question.prompt(
-                            query=query,
-                            relevant_docs=[
-                                doc.source_code for doc in relevant_docs],
-                        ),
-                    }
-                ]
+                
+                qa_strategy = get_qa_strategy(self.args.rag_qa_conversation_strategy)
+                new_conversations = qa_strategy.create_conversation(
+                    documents=[doc.source_code for doc in relevant_docs],
+                    conversations=conversations
+                )                
 
                 chunks = target_llm.stream_chat_oai(
                     conversations=new_conversations,
@@ -860,7 +842,7 @@ class LongContextRAG:
                         chunk[1].generated_tokens_count = rag_stat.recall_stat.total_generated_tokens + \
                             rag_stat.chunk_stat.total_generated_tokens + \
                             rag_stat.answer_stat.total_generated_tokens
-                        
+
                     yield chunk
 
                 self._print_rag_stats(rag_stat)

auto_coder-0.1.284/src/autocoder/rag/qa_conversation_strategy.py

@@ -0,0 +1,132 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any,Generator
+import byzerllm
+
+class QAConversationStrategy(ABC):
+    """
+    Abstract base class for conversation strategies.
+    Different strategies organize documents and conversations differently.
+    """
+    @abstractmethod
+    def create_conversation(self, documents: List[Any], conversations: List[Dict[str,str]]) -> List[Dict]:
+        """
+        Create a conversation structure based on documents and history
+        
+        Args:
+            documents: List of retrieved documents
+            conversations: conversation turns
+            
+        Returns:
+            List of message dictionaries representing the conversation to send to the model
+        """
+        pass
+
+class MultiRoundStrategy(QAConversationStrategy):
+    """
+    Multi-round strategy: First let the model read documents, then do Q&A.
+    Creates multiple conversation turns.
+    """
+    def create_conversation(self, documents: List[Any], conversations: List[Dict[str,str]]) -> List[Dict]:
+        messages = []    
+        messages.extend([
+            {"role": "user", "content": self._read_docs_prompt.prompt(documents)},
+            {"role": "assistant", "content": "好的"}
+        ]) 
+        messages.extend(conversations)
+        return messages
+    
+    @byzerllm.prompt()
+    def _read_docs_prompt(
+        self, relevant_docs: List[str]
+    ) -> Generator[str, None, None]:
+        """        
+        请阅读以下：
+        <documents>
+        {% for doc in relevant_docs %}
+        {{ doc }}
+        {% endfor %}
+        </documents>
+
+        阅读完成后，使用以上文档来回答用户的问题。回答要求：
+
+        1. 严格基于文档内容回答        
+        - 如果文档提供的信息无法回答问题,请明确回复:"抱歉,文档中没有足够的信息来回答这个问题。" 
+        - 不要添加、推测或扩展文档未提及的信息
+
+        2. 格式如 ![image](./path.png) 的 Markdown 图片处理
+        - 根据Markdown 图片前后文本内容推测改图片与问题的相关性，有相关性则在回答中输出该Markdown图片路径
+        - 根据相关图片在文档中的位置，自然融入答复内容,保持上下文连贯
+        - 完整保留原始图片路径,不省略任何部分
+
+        3. 回答格式要求
+        - 使用markdown格式提升可读性        
+        """
+
+class SingleRoundStrategy(QAConversationStrategy):
+    """
+    Single-round strategy: Put documents and conversation history in a single round.
+    """
+    def create_conversation(self, documents: List[Any], conversations: List[Dict[str,str]]) -> List[Dict]:
+        messages = []                
+        messages.extend([
+            {"role": "user", "content": self._single_round_answer_question.prompt(documents, conversations)}
+        ])         
+        return messages
+    
+    @byzerllm.prompt()
+    def _single_round_answer_question(
+        self, relevant_docs: List[str], conversations: List[Dict[str, str]]
+    ) -> Generator[str, None, None]:
+        """        
+        文档：
+        <documents>
+        {% for doc in relevant_docs %}
+        {{ doc }}
+        {% endfor %}
+        </documents>
+
+        用户历史对话：
+        <conversations>
+        {% for msg in conversations %}
+        <{{ msg.role }}>: {{ msg.content }}
+        {% endfor %}
+        </conversations>
+
+        使用以上文档来回答用户最后的问题。回答要求：
+
+        1. 严格基于文档内容回答        
+        - 如果文档提供的信息无法回答问题,请明确回复:"抱歉,文档中没有足够的信息来回答这个问题。" 
+        - 不要添加、推测或扩展文档未提及的信息
+
+        2. 格式如 ![image](./path.png) 的 Markdown 图片处理
+        - 根据Markdown 图片前后文本内容推测改图片与问题的相关性，有相关性则在回答中输出该Markdown图片路径
+        - 根据相关图片在文档中的位置，自然融入答复内容,保持上下文连贯
+        - 完整保留原始图片路径,不省略任何部分
+
+        3. 回答格式要求
+        - 使用markdown格式提升可读性
+        
+        """
+
+def get_qa_strategy(strategy_name: str) -> QAConversationStrategy:
+    """
+    Factory method to get the appropriate conversation strategy
+    
+    Args:
+        strategy_name: Name of the strategy to use
+        
+    Returns:
+        An instance of the requested strategy
+        
+    Raises:
+        ValueError: If the requested strategy doesn't exist
+    """
+    strategies = {
+        "multi_round": MultiRoundStrategy,
+        "single_round": SingleRoundStrategy,
+    }
+    
+    if strategy_name not in strategies:
+        raise ValueError(f"Unknown strategy: {strategy_name}. Available strategies: {list(strategies.keys())}")
+    
+    return strategies[strategy_name]()

auto_coder-0.1.284/src/autocoder/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.284"

auto_coder-0.1.282/src/autocoder/version.py

@@ -1 +0,0 @@
-__version__ = "0.1.282"