chATLAS_Chains 0.1.7__tar.gz → 0.3.0__tar.gz

{chatlas_chains-0.1.7 → chatlas_chains-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chATLAS_Chains
-Version: 0.1.7
+Version: 0.3.0
 Summary: A modular Python package for implementing Retrieval Augmented Generation chains for the chATLAS project.
 Author-email: Joe Egan <joseph.caimin.egan@cern.ch>
 License: Apache-2.0
@@ -78,6 +78,63 @@ More details [here](chATLAS_Chains/chains/README.md)
 - `chains.basic.basic_retrieval_chain`
 - `chains.advanced.advanced_rag`
 
+## Prompt Routing
+
+`chATLAS_Chains.router.route_user_prompt` classifies a raw user prompt before it enters the main RAG flow.
+The router defaults to CERN LiteLLM and returns a validated `RouterDecision` with:
+
+- `route`: one of `hep_atlas`, `person_lookup`, `dangerous`, `out_of_scope`,
+  or `unknown`
+- `confidence`: score from 0 to 1
+- `normalized_query`: cleaned prompt for downstream use
+- `search_kwargs`: optional search parameters
+- `metadata`: route-specific parameters
+
+For implementation details and a function-by-function reference, see the
+frontend reviewer document:
+[`../chATLAS_Frontend/docs/INTENT_ROUTER.md`](../chATLAS_Frontend/docs/INTENT_ROUTER.md).
+
+```python
+from chATLAS_Chains.router import route_user_prompt
+
+decision = route_user_prompt(
+    "Who is Jane Doe?",
+    chat_model_kwargs={
+        "service_provider": "litellm",
+        "proxy": "socks5h://localhost:1080",  # optional when outside CERN
+    },
+)
+
+if decision.route == "dangerous":
+    print("Apply the safety response policy")
+elif decision.route == "person_lookup":
+    print("Use the person lookup flow")
+elif decision.route == "hep_atlas":
+    print("Use the HEP/ATLAS search flow")
+elif decision.route == "out_of_scope":
+    print("Explain the chATLAS scope")
+else:
+    print("Ask for clarification")
+```
+
+The dedicated `mc_request` route is currently disabled until the MC workflow is
+ready. MC production and job-option prompts are classified as `hep_atlas` and
+continue through the normal selected workflow.
+
+Router context uses a hybrid policy: the current user prompt is authoritative,
+and recent conversation context is only a bounded disambiguation aid for
+follow-ups such as "What about Run 3?". The router keeps recent user prompts,
+includes only short assistant messages, and drops long assistant answers rather
+than summarizing them.
+
+For live LiteLLM calls, set:
+
+```sh
+export CHATLAS_CHAINS_LITELLM_KEY="your litellm key"
+```
+
+If LiteLLM is unavailable or returns invalid JSON, the router falls back to deterministic rules by default.
+
 ### Model Configuration in Chains
 
 Supported chain constructors now accept a typed `chat_model_kwargs` argument for model options (for example:

{chatlas_chains-0.1.7 → chatlas_chains-0.3.0}/README.md

@@ -52,6 +52,63 @@ More details [here](chATLAS_Chains/chains/README.md)
 - `chains.basic.basic_retrieval_chain`
 - `chains.advanced.advanced_rag`
 
+## Prompt Routing
+
+`chATLAS_Chains.router.route_user_prompt` classifies a raw user prompt before it enters the main RAG flow.
+The router defaults to CERN LiteLLM and returns a validated `RouterDecision` with:
+
+- `route`: one of `hep_atlas`, `person_lookup`, `dangerous`, `out_of_scope`,
+  or `unknown`
+- `confidence`: score from 0 to 1
+- `normalized_query`: cleaned prompt for downstream use
+- `search_kwargs`: optional search parameters
+- `metadata`: route-specific parameters
+
+For implementation details and a function-by-function reference, see the
+frontend reviewer document:
+[`../chATLAS_Frontend/docs/INTENT_ROUTER.md`](../chATLAS_Frontend/docs/INTENT_ROUTER.md).
+
+```python
+from chATLAS_Chains.router import route_user_prompt
+
+decision = route_user_prompt(
+    "Who is Jane Doe?",
+    chat_model_kwargs={
+        "service_provider": "litellm",
+        "proxy": "socks5h://localhost:1080",  # optional when outside CERN
+    },
+)
+
+if decision.route == "dangerous":
+    print("Apply the safety response policy")
+elif decision.route == "person_lookup":
+    print("Use the person lookup flow")
+elif decision.route == "hep_atlas":
+    print("Use the HEP/ATLAS search flow")
+elif decision.route == "out_of_scope":
+    print("Explain the chATLAS scope")
+else:
+    print("Ask for clarification")
+```
+
+The dedicated `mc_request` route is currently disabled until the MC workflow is
+ready. MC production and job-option prompts are classified as `hep_atlas` and
+continue through the normal selected workflow.
+
+Router context uses a hybrid policy: the current user prompt is authoritative,
+and recent conversation context is only a bounded disambiguation aid for
+follow-ups such as "What about Run 3?". The router keeps recent user prompts,
+includes only short assistant messages, and drops long assistant answers rather
+than summarizing them.
+
+For live LiteLLM calls, set:
+
+```sh
+export CHATLAS_CHAINS_LITELLM_KEY="your litellm key"
+```
+
+If LiteLLM is unavailable or returns invalid JSON, the router falls back to deterministic rules by default.
+
 ### Model Configuration in Chains
 
 Supported chain constructors now accept a typed `chat_model_kwargs` argument for model options (for example:

{chatlas_chains-0.1.7 → chatlas_chains-0.3.0}/chATLAS_Chains/chains/advanced.py

@@ -62,6 +62,7 @@ def advanced_rag(
     pinecone_api_key: str | None = None,
     rrf_constant: float = 60.0,
     rrf_weights: dict[str, float] | None = None,
+    skip_generation: bool = False,
 ) -> CompiledStateGraph:
     """
     Advanced Agentic RAG graph with optional query rewriting, dual-stage reranking and self-evaluation.
@@ -227,50 +228,62 @@ def advanced_rag(
     # --------------- Build the graph ---------------
     graph = StateGraph(HybridGraphState)
 
-    # Add all the nodes, but don't link to them if not using
     graph.add_node("query_rewrite", query_rewriting)
     graph.add_node("retrieval", retrieval)
     graph.add_node("rrf", rrf)
     graph.add_node("rerank", rerank)
-    graph.add_node("generate", generate_answer)
-    # graph.add_node("assess", assess_answer)
-    # graph.add_node("refine", refine_answer)
+    if not skip_generation:
+        graph.add_node("generate", generate_answer)
 
     if enable_query_rewriting:
-        # rewrite the query first
         graph.add_edge("query_rewrite", "retrieval")
         graph.set_entry_point("query_rewrite")
     else:
-        # start with retrieval
         graph.set_entry_point("retrieval")
 
-    if not enable_rrf and not enable_reranking:
-        # no document processing, go straight to generation
-        graph.add_edge("retrieval", "generate")
-
-    elif enable_rrf and not enable_reranking:
-        # retrieve → rrf → generate
+    # Determine the last pre-generation node
+    if enable_rrf and enable_reranking:
+        last_node = "rerank"
         graph.add_edge("retrieval", "rrf")
-        graph.add_edge("rrf", "generate")
-
-    elif not enable_rrf and enable_reranking:
-        # retrieve → rerank → generate
+        graph.add_edge("rrf", "rerank")
+    elif enable_rrf:
+        last_node = "rrf"
+        graph.add_edge("retrieval", "rrf")
+    elif enable_reranking:
+        last_node = "rerank"
         graph.add_edge("retrieval", "rerank")
-        graph.add_edge("rerank", "generate")
-
     else:
-        # retrieve → rrf → rerank → generate
-        graph.add_edge("retrieval", "rrf")
-        graph.add_edge("rrf", "rerank")
-        graph.add_edge("rerank", "generate")
+        last_node = "retrieval"
 
-    # generate at the end
-    graph.add_edge("generate", END)
+    if skip_generation:
+        graph.add_edge(last_node, END)
+    else:
+        graph.add_edge(last_node, "generate")
+        graph.add_edge("generate", END)
 
-    # Compile the graph
     return graph.compile()
 
 
+def build_generation_prompt(prompt: str | None = None) -> ChatPromptTemplate:
+    """Build the prompt template used by the generation step."""
+    if prompt is None:
+        prompt = CHAT_PROMPT_TEMPLATE
+    return ChatPromptTemplate.from_template(prompt)
+
+
+def stream_generate_answer(state: HybridGraphState, model, prompt_template: ChatPromptTemplate):
+    """Generator that streams LLM tokens for the generation step."""
+    prompt_input = {
+        "context": combine_documents(state["docs"]),
+        "question": state["question"],
+        "chat_history": state.get("chat_history", ""),
+    }
+    final_prompt = prompt_template.format_messages(**prompt_input)
+    for chunk in model.stream(final_prompt):
+        if chunk.content:
+            yield chunk.content
+
+
 if __name__ == "__main__":
     from chATLAS_Chains.llm.model_selection import GROQ_PRODUCTION_MODELS
     from chATLAS_Chains.vectorstore import get_vectorstore

{chatlas_chains-0.1.7 → chatlas_chains-0.3.0}/chATLAS_Chains/chains/conversational_graph.py

@@ -16,7 +16,7 @@ from langgraph.graph.message import add_messages
 from langgraph.graph.state import CompiledStateGraph
 from sentence_transformers.util import cos_sim
 
-from chATLAS_Chains.chains.advanced import advanced_rag
+from chATLAS_Chains.chains.advanced import advanced_rag, build_generation_prompt, stream_generate_answer
 from chATLAS_Chains.llm.model_selection import (
     GROQ_PRODUCTION_MODELS,
     ChatModelKwargs,
@@ -27,6 +27,7 @@ from chATLAS_Chains.prompt.starters import (
     CHAT_PROMPT_TEMPLATE,
     CONVERSATIONAL_CHAT_PROMPT_TEMPLATE,
     QUERY_CONTEXTUALIZATION_PROMPT,
+    STREAMING_PRODUCTION_PROMPT_TEMPLATE,
 )
 
 logger = logging.getLogger(__name__)
@@ -176,21 +177,19 @@ def conversational_retrieval_graph(
         prompt = CONVERSATIONAL_CHAT_PROMPT_TEMPLATE
 
     if contextualization_model is None:
-        contextualization_model = query_rewriting_model
+        contextualization_model = "gpt-5-nano"
+        # gpt-5 family does not support max_tokens or temperature params;
+        # override any inherited kwargs to avoid silent empty responses
+        contextualization_chat_model_kwargs = {"service_provider": "openai"}
 
     primary_model_kwargs = sanitize_chat_model_kwargs(chat_model_kwargs)
 
     contextualization_llm = None
     if enable_query_contextualization:
-        contextualization_kwargs: ChatModelKwargs = {
-            **primary_model_kwargs,
-            "max_tokens": 256,
-            "temperature": 0.1,
-        }
-        contextualization_kwargs.update(sanitize_chat_model_kwargs(contextualization_chat_model_kwargs))
+        ctx_kwargs = sanitize_chat_model_kwargs(contextualization_chat_model_kwargs)
         contextualization_llm = get_chat_model(
             model_name=contextualization_model,
-            **contextualization_kwargs,
+            **ctx_kwargs,
         )
         contextualization_prompt = ChatPromptTemplate.from_template(QUERY_CONTEXTUALIZATION_PROMPT)
 
@@ -235,7 +234,9 @@ def conversational_retrieval_graph(
         try:
             formatted_prompt = contextualization_prompt.format(chat_history=chat_history, question=question)
             response = contextualization_llm.invoke(formatted_prompt)
-            standalone_question = str(response.content).strip()
+            rewritten = str(response.content).strip()
+            # Model sometimes returns empty when it means "unchanged" — fall back to original
+            standalone_question = rewritten if rewritten else question
 
             if standalone_question != question:
                 logger.info(f"Contextualized question: '{question}' -> '{standalone_question}'")
@@ -323,6 +324,197 @@ def conversational_retrieval_graph(
     return graph.compile(checkpointer=checkpointer)
 
 
+def conversational_retrieval_streaming(
+    vectorstore,
+    model_name: str,
+    checkpointer: BaseCheckpointSaver,
+    thread_id: str,
+    user_input: str,
+    search_kwargs: dict,
+    prompt: str | None = None,
+    chat_model_kwargs: ChatModelKwargs | None = None,
+    enable_query_rewriting: bool = False,
+    enable_rrf: bool = True,
+    enable_reranking: bool = False,
+    enable_query_contextualization: bool = True,
+    query_rewriting_model: str | None = None,
+    query_rewriting_chat_model_kwargs: ChatModelKwargs | None = None,
+    contextualization_model: str | None = None,
+    contextualization_chat_model_kwargs: ChatModelKwargs | None = None,
+    max_turns: int = 10,
+    rerank_model: str = "cohere-rerank-3.5",
+    pinecone_api_key: str | None = None,
+    rrf_constant: float = 60.0,
+    rrf_weights: dict[str, float] | None = None,
+    embedder=None,
+    source_names: list[str] | None = None,
+):
+    """Streaming variant of the conversational retrieval graph.
+
+    Generator that yields status dicts during pipeline execution,
+    then yields the final ``(docs, StreamingSession)`` tuple.
+    """
+    if prompt is None:
+        prompt = STREAMING_PRODUCTION_PROMPT_TEMPLATE
+    if query_rewriting_model is None:
+        query_rewriting_model = model_name
+    if contextualization_model is None:
+        contextualization_model = "gpt-5-nano"
+        # gpt-5 family does not support max_tokens or temperature params;
+        # override any inherited kwargs to avoid silent empty responses
+        contextualization_chat_model_kwargs = {"service_provider": "openai"}
+
+    primary_model_kwargs = sanitize_chat_model_kwargs(chat_model_kwargs)
+
+    conv_graph = conversational_retrieval_graph(
+        vectorstore=vectorstore,
+        model_name=model_name,
+        checkpointer=checkpointer,
+        prompt=prompt,
+        chat_model_kwargs=chat_model_kwargs,
+        enable_query_rewriting=enable_query_rewriting,
+        enable_rrf=enable_rrf,
+        enable_reranking=enable_reranking,
+        enable_query_contextualization=enable_query_contextualization,
+        query_rewriting_model=query_rewriting_model,
+        query_rewriting_chat_model_kwargs=query_rewriting_chat_model_kwargs,
+        contextualization_model=contextualization_model,
+        contextualization_chat_model_kwargs=contextualization_chat_model_kwargs,
+        max_turns=max_turns,
+        rerank_model=rerank_model,
+        pinecone_api_key=pinecone_api_key,
+        rrf_constant=rrf_constant,
+        rrf_weights=rrf_weights,
+        embedder=embedder,
+    )
+
+    config = {"configurable": {"thread_id": thread_id}}
+    existing_state = conv_graph.get_state(config)
+    existing_messages = existing_state.values.get("messages", []) if existing_state.values else []
+
+    if max_turns is not None and len(existing_messages) >= max_turns * 2:
+        limit_msg = f"Conversation turn limit ({max_turns}) reached. Please start a new thread."
+        conv_graph.update_state(config, {"messages": [HumanMessage(content=user_input), AIMessage(content=limit_msg)]})
+        yield ([], _LimitReachedSession(limit_msg))
+        return
+
+    all_messages = [*existing_messages, HumanMessage(content=user_input)]
+
+    standalone_question = user_input
+    if enable_query_contextualization:
+        yield {"type": "status", "stage": "contextualizing", "message": "Analyzing query..."}
+
+        ctx_kwargs = sanitize_chat_model_kwargs(contextualization_chat_model_kwargs)
+        ctx_llm = get_chat_model(model_name=contextualization_model, **ctx_kwargs)
+        ctx_prompt = ChatPromptTemplate.from_template(QUERY_CONTEXTUALIZATION_PROMPT)
+
+        history_messages = [m for m in all_messages if m.content != user_input]
+        if history_messages and embedder is not None:
+            history_messages = select_relevant_history(
+                user_input, history_messages, embedder, max_messages=max_turns * 2
+            )
+        chat_history = (
+            format_chat_history(history_messages, max_turns=max_turns)
+            if history_messages
+            else "(No previous conversation)"
+        )
+
+        try:
+            formatted = ctx_prompt.format(chat_history=chat_history, question=user_input)
+            response = ctx_llm.invoke(formatted)
+            rewritten = str(response.content).strip()
+            # Model sometimes returns empty when it means "unchanged" — fall back to original
+            standalone_question = rewritten if rewritten else user_input
+            if standalone_question != user_input:
+                logger.info(f"Contextualized question: '{user_input}' -> '{standalone_question}'")
+                yield {"type": "status", "stage": "contextualizing", "message": f"Searching for: {standalone_question}"}
+        except Exception as e:
+            logger.warning(f"Query contextualization failed: {e}. Using original question.")
+
+    sources_label = ", ".join(source_names) if source_names else "documents"
+    yield {"type": "status", "stage": "searching", "message": f"Searching {sources_label}..."}
+
+    retrieval_graph = advanced_rag(
+        vectorstore=vectorstore,
+        model_name=model_name,
+        prompt=prompt,
+        chat_model_kwargs=chat_model_kwargs,
+        enable_query_rewriting=enable_query_rewriting,
+        enable_rrf=enable_rrf,
+        enable_reranking=enable_reranking,
+        query_rewriting_model=query_rewriting_model,
+        query_rewriting_chat_model_kwargs=query_rewriting_chat_model_kwargs,
+        rerank_model=rerank_model,
+        pinecone_api_key=pinecone_api_key,
+        rrf_constant=rrf_constant,
+        rrf_weights=rrf_weights,
+        skip_generation=True,
+    )
+
+    history_for_generation = format_chat_history(
+        [m for m in all_messages if m.content != user_input], max_turns=max_turns
+    )
+    retrieval_result = retrieval_graph.invoke(
+        {
+            "question": standalone_question,
+            "search_kwargs": search_kwargs,
+            "chat_history": history_for_generation,
+        }
+    )
+    docs = retrieval_result.get("docs", [])
+
+    yield {"type": "status", "stage": "generating", "message": "Thinking..."}
+
+    streaming_model = get_chat_model(model_name, **primary_model_kwargs)
+    prompt_template = build_generation_prompt(prompt)
+
+    session = _StreamingSession(
+        retrieval_state=retrieval_result,
+        model=streaming_model,
+        prompt_template=prompt_template,
+        conv_graph=conv_graph,
+        config=config,
+        user_input=user_input,
+    )
+    yield (docs, session)
+
+
+class _StreamingSession:
+    def __init__(self, retrieval_state, model, prompt_template, conv_graph, config, user_input):
+        self._retrieval_state = retrieval_state
+        self._model = model
+        self._prompt_template = prompt_template
+        self._conv_graph = conv_graph
+        self._config = config
+        self._user_input = user_input
+        self._full_text = ""
+
+    def stream_tokens(self):
+        for token in stream_generate_answer(self._retrieval_state, self._model, self._prompt_template):
+            self._full_text += token
+            yield token
+
+    def finalize(self):
+        self._conv_graph.update_state(
+            self._config,
+            {
+                "messages": [HumanMessage(content=self._user_input), AIMessage(content=self._full_text)],
+            },
+        )
+        return self._full_text
+
+
+class _LimitReachedSession:
+    def __init__(self, message):
+        self._message = message
+
+    def stream_tokens(self):
+        yield self._message
+
+    def finalize(self):
+        return self._message
+
+
 if __name__ == "__main__":
     from langchain_core.messages import HumanMessage
     from langgraph.checkpoint.memory import InMemorySaver

{chatlas_chains-0.1.7 → chatlas_chains-0.3.0}/chATLAS_Chains/llm/groq.py

@@ -11,7 +11,8 @@ from typing import Any, Optional
 import requests
 from langchain_core.language_models.chat_models import BaseChatModel
 from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage
-from langchain_core.outputs import ChatGeneration, ChatResult
+from langchain_core.messages.ai import AIMessageChunk
+from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult
 from pydantic import BaseModel, Field, SecretStr
 from requests.exceptions import ConnectionError, RequestException, Timeout
 
@@ -545,8 +546,116 @@ class AccGPTChatGroq(BaseChatModel, BaseModel):
                     logger.info("Retryable error occurred, trying next model...")
                     continue
 
-    def _stream(self, **kwargs):
-        raise NotImplementedError("AccGPTChatGroqRateLimitAware does not support streaming yet.")
+    def _stream(self, messages: list[BaseMessage], **kwargs):
+        """Stream tokens from the Groq API with retry and fallback support."""
+        models_to_try = [self.model_name, *self.fallback_models]
+
+        for i, model in enumerate(models_to_try):
+            try:
+                logger.info(f"Streaming with model {i + 1}/{len(models_to_try)}: {model}")
+                yield from self._make_streaming_request(messages, model)
+                return
+            except GroqAPIError as e:
+                logger.error(f"Streaming model {model} failed: {e!s}")
+                if i == len(models_to_try) - 1:
+                    raise e
+                logger.info("Trying next model...")
+
+    def _make_streaming_request(self, messages: list[BaseMessage], model_name: str):
+        """Make a single streaming API request with retry logic."""
+        formatted_messages = []
+        for message in messages:
+            if isinstance(message, SystemMessage):
+                formatted_messages.append({"role": "system", "content": message.content})
+            elif isinstance(message, HumanMessage):
+                formatted_messages.append({"role": "user", "content": message.content})
+            elif isinstance(message, AIMessage):
+                formatted_messages.append({"role": "assistant", "content": message.content})
+
+        chat_payload = {"messages": formatted_messages, "model": model_name, "n": 1, "stream": True}
+        if self.max_tokens is not None:
+            chat_payload["max_tokens"] = self.max_tokens
+        if self.temperature is not None:
+            chat_payload["temperature"] = self.temperature
+
+        url = f"{self.base_url.get_secret_value()}/chat"
+        headers = {"X-API-Key": self.api_key.get_secret_value()}
+
+        last_exception = None
+        for attempt in range(self.retry_config.max_retries + 1):
+            try:
+                if attempt > 0:
+                    rate_limit_info = getattr(last_exception, "rate_limit_info", None) if last_exception else None
+                    delay = self._calculate_delay(attempt - 1, rate_limit_info)
+                    if delay > 0:
+                        logger.info(
+                            f"Stream retry {attempt + 1}/{self.retry_config.max_retries + 1} after {delay:.2f}s"
+                        )
+                        time.sleep(delay)
+
+                response = requests.post(url, json=chat_payload, headers=headers, timeout=self.timeout, stream=True)
+
+                if response.status_code != 200:
+                    try:
+                        result = response.json()
+                    except json.JSONDecodeError:
+                        result = {"error": response.text[:500]}
+                    error_details, is_retryable, rate_limit_info = self._analyze_response_error(response, result)
+                    error_msg = f"Streaming request failed with status {response.status_code}: {error_details}"
+                    last_exception = GroqAPIError(
+                        error_msg,
+                        response_data=result,
+                        status_code=response.status_code,
+                        is_retryable=is_retryable,
+                        rate_limit_info=rate_limit_info,
+                    )
+                    if not is_retryable or attempt == self.retry_config.max_retries:
+                        raise last_exception
+                    continue
+
+                # Stream tokens from SSE response
+                for line in response.iter_lines(decode_unicode=True):
+                    if not line:
+                        continue
+                    if not line.startswith("data: "):
+                        continue
+                    data_str = line[6:]
+                    if data_str.strip() == "[DONE]":
+                        return
+                    try:
+                        chunk_data = json.loads(data_str)
+                    except json.JSONDecodeError:
+                        continue
+
+                    choices = chunk_data.get("choices", [])
+                    if not choices:
+                        continue
+                    delta = choices[0].get("delta", {})
+                    content = delta.get("content", "")
+                    if content:
+                        yield ChatGenerationChunk(message=AIMessageChunk(content=content))
+
+                    if choices[0].get("finish_reason") == "length":
+                        logger.warning("Streaming: model ran out of tokens before completing response")
+                return
+
+            except (Timeout, ConnectionError, RequestException) as e:
+                error_msg = f"Stream network error: {e!s}"
+                logger.error(error_msg)
+                last_exception = GroqAPIError(error_msg, is_retryable=True)
+                if attempt == self.retry_config.max_retries:
+                    raise last_exception
+                continue
+
+            except GroqAPIError as e:
+                last_exception = e
+                if not e.is_retryable or attempt == self.retry_config.max_retries:
+                    raise e
+                continue
+
+        if last_exception:
+            raise last_exception
+        raise GroqAPIError("All streaming retry attempts failed")
 
     @property
     def _llm_type(self) -> str:

{chatlas_chains-0.1.7 → chatlas_chains-0.3.0}/chATLAS_Chains/prompt/starters.py

@@ -185,6 +185,35 @@ Provide your response prioritizing ATLAS internal sources:
 }}
 """
 
+STREAMING_PRODUCTION_PROMPT_TEMPLATE = """
+You are an elite-level physicist specializing in high-energy physics, specifically within the ATLAS collaboration at CERN.
+ Your role is to serve as a highly reliable expert assistant, providing precise, accurate, and contextually relevant answers to professional physicists' inquiries.
+
+### Instructions:
+- **Use Only Provided Context:** You must strictly base your answers on the supplied context. Do not speculate, hallucinate, or fabricate information.
+- **Answer with Clarity and Precision:** Provide clear, concise, and technically accurate responses. Use professional and scientific language appropriate for CERN physicists.
+- **Format and Cite Properly:**
+    - Use Markdown for structured formatting (e.g., `**bold**` for emphasis, lists for steps, and code blocks for technical content).
+    - When citing a source, reference it inline using the exact document name in square brackets, e.g. [DocumentName].
+- **Show Reasoning and Steps:** When applicable, break down complex answers into clear, logical steps.
+- **Handle Ambiguity:** If the question or context is ambiguous, specify the missing details and suggest clarifying questions.
+- **Prioritize Caution and Verifiability:** When the context is limited, explicitly state the lack of sufficient information rather than making unsupported inferences.
+- **Context Prioritization:** When multiple sources provide relevant information, prioritize: (1) official ATLAS documentation, (2) peer-reviewed publications, (3) technical notes, (4) meeting minutes.
+- **Temporal Awareness:** Be attentive to publication dates in the provided context.
+- **Technical Terminology:** Maintain consistency with ATLAS-specific conventions.
+
+### Conversation History:
+{chat_history}
+
+### Context (from ATLAS documentation and wiki pages):
+{context}
+
+### Question:
+{question}
+
+### Response:
+"""
+
 QUERY_CONTEXTUALIZATION_PROMPT = """
 # Role
 You are a query rewriter for a Retrieval-Augmented Generation (RAG) system in high-energy physics (ATLAS/CERN).