langchain-timbr 2.1.14__py3-none-any.whl → 3.0.0__py3-none-any.whl

langchain_timbr/utils/timbr_llm_utils.py

@@ -268,6 +268,7 @@ def determine_concept(
 ) -> dict[str, Any]:
     usage_metadata = {}
     determined_concept_name = None
+    identify_concept_reason = None
     schema = 'dtimbr'
     
     # Use config default timeout if none provided
@@ -339,10 +340,21 @@ def determine_concept(
             if debug:
                 usage_metadata['determine_concept']["p_hash"] = encrypt_prompt(prompt)
 
-            response_text = _get_response_text(response)
-            candidate = response_text.strip()
+            # Try to parse as JSON first (with 'result' and 'reason' keys)
+            try:
+                parsed_response = _parse_json_from_llm_response(response)
+                if isinstance(parsed_response, dict) and 'result' in parsed_response:
+                    candidate = parsed_response.get('result', '').strip()
+                    identify_concept_reason = parsed_response.get('reason', None)
+                else:
+                    # Fallback to plain text if JSON doesn't have expected structure
+                    candidate = _get_response_text(response).strip()
+            except (json.JSONDecodeError, ValueError):
+                # If not JSON, treat as plain text (backwards compatibility)
+                candidate = _get_response_text(response).strip()
+            
             if should_validate and candidate not in concepts_and_views.keys():
-                error = f"Concept '{determined_concept_name}' not found in the list of concepts."
+                error = f"Concept '{candidate}' not found in the list of concepts."
                 continue
             
             determined_concept_name = candidate
@@ -356,6 +368,7 @@ def determine_concept(
     return {
         "concept_metadata": concepts_and_views.get(determined_concept_name) if determined_concept_name else None,
         "concept": determined_concept_name,
+        "identify_concept_reason": identify_concept_reason,
         "schema": schema,
         "usage_metadata": usage_metadata,
     }
@@ -423,14 +436,45 @@ def _build_rel_columns_str(relationships: list[dict], columns_tags: Optional[dic
     return '.\n'.join(rel_str_arr) if rel_str_arr else ''
 
 
-def _parse_sql_from_llm_response(response: Any) -> str:
+def _parse_sql_and_reason_from_llm_response(response: Any) -> dict:
+    """
+    Parse SQL & reason from LLM response. Handles both plain SQL strings and JSON format with 'result' and 'reason' keys.
+    
+    Returns:
+        dict with 'sql' and 'reason' keys (reason may be None if not provided)
+    """
+    # Try to parse as JSON first
+    try:
+        parsed_json = _parse_json_from_llm_response(response)
+        
+        # Extract SQL from 'result' key and reason from 'reason' key
+        if isinstance(parsed_json, dict) and 'result' in parsed_json:
+            sql = parsed_json.get('result', '')
+            reason = parsed_json.get('reason', None)
+            
+            # Clean the SQL
+            sql = (sql
+                   .replace("```sql", "")
+                   .replace("```", "")
+                   .replace('SELECT \n', 'SELECT ')
+                   .replace(';', '')
+                   .strip())
+            
+            return {'sql': sql, 'reason': reason}
+    except (json.JSONDecodeError, ValueError):
+        # If not JSON, treat as plain SQL string (backwards compatibility)
+        pass
+    
+    # Fallback to plain text parsing
     response_text = _get_response_text(response)
-    return (response_text
-            .replace("```sql", "")
-            .replace("```", "")
-            .replace('SELECT \n', 'SELECT ')
-            .replace(';', '')
-            .strip())
+    sql = (response_text
+           .replace("```sql", "")
+           .replace("```", "")
+           .replace('SELECT \n', 'SELECT ')
+           .replace(';', '')
+           .strip())
+    
+    return {'sql': sql, 'reason': None}
 
 
 def _get_active_datasource(conn_params: dict) -> dict:
@@ -438,6 +482,38 @@ def _get_active_datasource(conn_params: dict) -> dict:
     return datasources[0] if datasources else None
 
 
+def _parse_json_from_llm_response(response: Any) -> dict:
+    """
+    Parse JSON from LLM response. Handles markdown code blocks and extracts valid JSON.
+    
+    Args:
+        response: LLM response object
+        
+    Returns:
+        dict containing parsed JSON
+        
+    Raises:
+        json.JSONDecodeError: If response cannot be parsed as JSON
+        ValueError: If response format is unexpected
+    """
+    response_text = _get_response_text(response)
+    
+    # Remove markdown code block markers if present
+    content = response_text.strip()
+    if content.startswith("```json"):
+        content = content[7:]  # Remove ```json
+    elif content.startswith("```"):
+        content = content[3:]  # Remove ```
+    
+    if content.endswith("```"):
+        content = content[:-3]  # Remove closing ```
+    
+    content = content.strip()
+    
+    # Parse and return JSON
+    return json.loads(content)
+
+
 def _evaluate_sql_enable_reasoning(
     question: str,
     sql_query: str,
@@ -463,22 +539,8 @@ def _evaluate_sql_enable_reasoning(
     
     response = _call_llm_with_timeout(llm, prompt, timeout=timeout)
     
-    # Extract JSON from response content (handle markdown code blocks)
-    content = response.content.strip()
-    
-    # Remove markdown code block markers if present
-    if content.startswith("```json"):
-        content = content[7:]  # Remove ```json
-    elif content.startswith("```"):
-        content = content[3:]  # Remove ```
-    
-    if content.endswith("```"):
-        content = content[:-3]  # Remove closing ```
-    
-    content = content.strip()
-    
     # Parse JSON response
-    evaluation = json.loads(content)
+    evaluation = _parse_json_from_llm_response(response)
     
     return {
         "evaluation": evaluation,
@@ -571,11 +633,9 @@ def _build_sql_generation_context(
 def _generate_sql_with_llm(
     question: str,
     llm: LLM,
-    conn_params: dict,
     generate_sql_prompt: Any,
     current_context: dict,
     note: str,
-    should_validate_sql: bool,
     timeout: int,
     debug: bool = False,
 ) -> dict:
@@ -614,8 +674,12 @@ def _generate_sql_with_llm(
     
     response = _call_llm_with_timeout(llm, prompt, timeout=timeout)
     
+    # Parse response which now includes both SQL and reason
+    parsed_response = _parse_sql_and_reason_from_llm_response(response)
+    
     result = {
-        "sql": _parse_sql_from_llm_response(response),
+        "sql": parsed_response['sql'],
+        "generate_sql_reason": parsed_response['reason'],
         "apx_token_count": apx_token_count,
         "usage_metadata": _extract_usage_metadata(response),
         "is_valid": True,
@@ -625,11 +689,163 @@ def _generate_sql_with_llm(
     if debug:
         result["p_hash"] = encrypt_prompt(prompt)
     
-    if should_validate_sql:
-        result["is_valid"], result["error"], result["sql"] = validate_sql(result["sql"], conn_params)
     
     return result
 
+def handle_generate_sql_reasoning(
+    sql_query: str,
+    question: str,
+    llm: LLM,
+    conn_params: dict,
+    schema: str,
+    concept: str,
+    concept_metadata: dict,
+    include_tags: bool,
+    exclude_properties: list,
+    db_is_case_sensitive: bool,
+    max_limit: int,
+    reasoning_steps: int,
+    note: str,
+    graph_depth: int,
+    usage_metadata: dict,
+    timeout: int,
+    debug: bool,
+) -> tuple[str, int, str]:
+    generate_sql_prompt = get_generate_sql_prompt_template(conn_params)
+    context_graph_depth = graph_depth
+    reasoned_sql = sql_query
+    reasoned_sql_reason = None
+    for step in range(reasoning_steps):
+        try:
+            # Step 1: Evaluate the current SQL
+            eval_result = _evaluate_sql_enable_reasoning(
+                question=question,
+                sql_query=reasoned_sql,
+                llm=llm,
+                conn_params=conn_params,
+                timeout=timeout,
+            )
+            
+            usage_metadata[f'sql_reasoning_step_{step + 1}'] = {
+                "approximate": eval_result['apx_token_count'],
+                **eval_result['usage_metadata'],
+            }
+            
+            evaluation = eval_result['evaluation']
+            reasoning_status = evaluation.get("assessment", "partial").lower()
+            
+            if reasoning_status == "correct":
+                break
+            
+            # Step 2: Regenerate SQL with feedback
+            evaluation_note = note + f"\n\nThe previously generated SQL: `{reasoned_sql}` was assessed as '{evaluation.get('assessment')}' because: {evaluation.get('reasoning', '*could not determine cause*')}. Please provide a corrected SQL query that better answers the question: '{question}'.\n\nCRITICAL: Return ONLY the SQL query without any explanation or comments."
+            
+            # Increase graph depth for 2nd+ reasoning attempts, up to max of 3
+            context_graph_depth = min(3, int(graph_depth) + step) if graph_depth < 3 and step > 0 else graph_depth
+            regen_result = _generate_sql_with_llm(
+                question=question,
+                llm=llm,
+                generate_sql_prompt=generate_sql_prompt,
+                current_context=_build_sql_generation_context(
+                    conn_params=conn_params,
+                    schema=schema,
+                    concept=concept,
+                    concept_metadata=concept_metadata,
+                    graph_depth=context_graph_depth,
+                    include_tags=include_tags,
+                    exclude_properties=exclude_properties,
+                    db_is_case_sensitive=db_is_case_sensitive,
+                    max_limit=max_limit),
+                note=evaluation_note,
+                timeout=timeout,
+                debug=debug,
+            )
+            
+            reasoned_sql = regen_result['sql']
+            reasoned_sql_reason = regen_result['generate_sql_reason']
+            error = regen_result['error']
+
+            step_key = f'generate_sql_reasoning_step_{step + 1}'
+            usage_metadata[step_key] = {
+                "approximate": regen_result['apx_token_count'],
+                **regen_result['usage_metadata'],
+            }
+            if debug and 'p_hash' in regen_result:
+                usage_metadata[step_key]['p_hash'] = regen_result['p_hash']
+
+            if error:
+                raise Exception(error)
+            
+        except TimeoutError as e:
+            raise Exception(f"LLM call timed out: {str(e)}")
+        except Exception as e:
+            print(f"Warning: LLM reasoning failed: {e}")
+            break
+    
+    return reasoned_sql, context_graph_depth, reasoned_sql_reason
+
+def handle_validate_generate_sql(
+    sql_query: str,
+    question: str,
+    llm: LLM,
+    conn_params: dict,
+    generate_sql_prompt: Any,
+    schema: str,
+    concept: str,
+    concept_metadata: dict,
+    include_tags: bool,
+    exclude_properties: list,
+    db_is_case_sensitive: bool,
+    max_limit: int,
+    graph_depth: int,
+    retries: int,
+    timeout: int,
+    debug: bool,
+    usage_metadata: dict,
+) -> tuple[bool, str, str]:
+    is_sql_valid, error, sql_query = validate_sql(sql_query, conn_params)
+    validation_attempt = 0
+  
+    while validation_attempt < retries and not is_sql_valid:
+        validation_attempt += 1
+        validation_err_txt = f"\nThe generated SQL (`{sql_query}`) was invalid with error: {error}. Please generate a corrected query that achieves the intended result." if error and "snowflake" not in llm._llm_type else ""
+
+        regen_result = _generate_sql_with_llm(
+            question=question,
+            llm=llm,
+            generate_sql_prompt=generate_sql_prompt,
+            current_context=_build_sql_generation_context(
+                conn_params=conn_params,
+                schema=schema,
+                concept=concept,
+                concept_metadata=concept_metadata,
+                graph_depth=graph_depth,
+                include_tags=include_tags,
+                exclude_properties=exclude_properties,
+                db_is_case_sensitive=db_is_case_sensitive,
+                max_limit=max_limit),
+            note=validation_err_txt,
+            timeout=timeout,
+            debug=debug,
+        )
+        
+        regen_error = regen_result['error']
+        sql_query = regen_result['sql']
+
+        validation_key = f'generate_sql_validation_regen_{validation_attempt}'
+        usage_metadata[validation_key] = {
+            "approximate": regen_result['apx_token_count'],
+            **regen_result['usage_metadata'],
+        }
+        if debug and 'p_hash' in regen_result:
+            usage_metadata[validation_key]['p_hash'] = regen_result['p_hash']
+
+        if regen_error:
+            raise Exception(regen_error)
+        
+        is_sql_valid, error, sql_query = validate_sql(sql_query, conn_params)
+
+    return is_sql_valid, error, sql_query
 
 def generate_sql(
         question: str,
@@ -656,13 +872,11 @@ def generate_sql(
     usage_metadata = {}
     concept_metadata = None
     reasoning_status = 'correct'
-    
+
     # Use config default timeout if none provided
     if timeout is None:
         timeout = config.llm_timeout
     
-    generate_sql_prompt = get_generate_sql_prompt_template(conn_params)
-   
     if concept and concept != "" and (schema is None or schema != "vtimbr"):
         concepts_list = [concept]
     elif concept and concept != "" and schema == "vtimbr":
@@ -682,154 +896,105 @@ def generate_sql(
         debug=debug,
         timeout=timeout,
     )
-    concept, schema, concept_metadata = determine_concept_res.get('concept'), determine_concept_res.get('schema'), determine_concept_res.get('concept_metadata')
+
+    concept = determine_concept_res.get('concept')
+    identify_concept_reason = determine_concept_res.get('identify_concept_reason', None)
+    schema = determine_concept_res.get('schema')
+    concept_metadata = determine_concept_res.get('concept_metadata')
     usage_metadata.update(determine_concept_res.get('usage_metadata', {}))
 
     if not concept:
         raise Exception("No relevant concept found for the query.")
 
+    generate_sql_prompt = get_generate_sql_prompt_template(conn_params)
     sql_query = None
-    iteration = 0
-    is_sql_valid = True
+    generate_sql_reason = None
+    is_sql_valid = True  # Assume valid by default; set to False only if validation fails
     error = ''
-    while sql_query is None or (should_validate_sql and iteration < retries and not is_sql_valid):
-        iteration += 1
-        err_txt = f"\nThe original SQL (`{sql_query}`) was invalid with error: {error}. Please generate a corrected query." if error and "snowflake" not in llm._llm_type else ""
 
-        try:
-            result = _generate_sql_with_llm(
+    try:
+        result = _generate_sql_with_llm(
+            question=question,
+            llm=llm,
+            generate_sql_prompt=generate_sql_prompt,
+            current_context=_build_sql_generation_context(
+                conn_params=conn_params,
+                schema=schema,
+                concept=concept,
+                concept_metadata=concept_metadata,
+                graph_depth=graph_depth,
+                include_tags=include_tags,
+                exclude_properties=exclude_properties,
+                db_is_case_sensitive=db_is_case_sensitive,
+                max_limit=max_limit),
+            note=note,
+            timeout=timeout,
+            debug=debug,
+        )
+        
+        usage_metadata['generate_sql'] = {
+            "approximate": result['apx_token_count'],
+            **result['usage_metadata'],
+        }
+        if debug and 'p_hash' in result:
+            usage_metadata['generate_sql']["p_hash"] = result['p_hash']
+        
+        sql_query = result['sql']
+        generate_sql_reason = result.get('generate_sql_reason', None)
+        error = result['error']
+
+        if error:
+            raise Exception(error)
+        
+        if enable_reasoning and sql_query is not None:
+            sql_query, graph_depth, generate_sql_reason = handle_generate_sql_reasoning(
+                sql_query=sql_query,
+                question=question,
+                llm=llm,
+                conn_params=conn_params,
+                schema=schema,
+                concept=concept,
+                concept_metadata=concept_metadata,
+                include_tags=include_tags,
+                exclude_properties=exclude_properties,
+                db_is_case_sensitive=db_is_case_sensitive,
+                max_limit=max_limit,
+                reasoning_steps=reasoning_steps,
+                note=note,
+                graph_depth=graph_depth,
+                usage_metadata=usage_metadata,
+                timeout=timeout,
+                debug=debug,
+            )
+
+        if should_validate_sql or enable_reasoning:
+            # Validate & regenerate only once if reasoning enabled and validation is disabled
+            validate_retries = 1 if not should_validate_sql else retries
+            is_sql_valid, error, sql_query = handle_validate_generate_sql(
+                sql_query=sql_query,
                 question=question,
                 llm=llm,
                 conn_params=conn_params,
                 generate_sql_prompt=generate_sql_prompt,
-                current_context=_build_sql_generation_context(
-                    conn_params=conn_params,
-                    schema=schema,
-                    concept=concept,
-                    concept_metadata=concept_metadata,
-                    graph_depth=graph_depth,
-                    include_tags=include_tags,
-                    exclude_properties=exclude_properties,
-                    db_is_case_sensitive=db_is_case_sensitive,
-                    max_limit=max_limit),
-                note=note + err_txt,
-                should_validate_sql=should_validate_sql,
+                schema=schema,
+                concept=concept,
+                concept_metadata=concept_metadata,
+                include_tags=include_tags,
+                exclude_properties=exclude_properties,
+                db_is_case_sensitive=db_is_case_sensitive,
+                max_limit=max_limit,
+                graph_depth=graph_depth,
+                retries=validate_retries,
                 timeout=timeout,
                 debug=debug,
+                usage_metadata=usage_metadata,
             )
-            
-            usage_metadata['generate_sql'] = {
-                "approximate": result['apx_token_count'],
-                **result['usage_metadata'],
-            }
-            if debug and 'p_hash' in result:
-                usage_metadata['generate_sql']["p_hash"] = result['p_hash']
-            
-            sql_query = result['sql']
-            is_sql_valid = result['is_valid']
-            error = result['error']
-            
-        except TimeoutError as e:
-            error = f"LLM call timed out: {str(e)}"
-            raise Exception(error)
-        except Exception as e:
-            error = f"LLM call failed: {str(e)}"
-            if should_validate_sql:
-                continue
-            else:
-                raise Exception(error)
-    
-    
-    if enable_reasoning and sql_query is not None:
-        for step in range(reasoning_steps):
-            try:
-                # Step 1: Evaluate the current SQL
-                eval_result = _evaluate_sql_enable_reasoning(
-                    question=question,
-                    sql_query=sql_query,
-                    llm=llm,
-                    conn_params=conn_params,
-                    timeout=timeout,
-                )
-                
-                usage_metadata[f'sql_reasoning_step_{step + 1}'] = {
-                    "approximate": eval_result['apx_token_count'],
-                    **eval_result['usage_metadata'],
-                }
-                
-                evaluation = eval_result['evaluation']
-                reasoning_status = evaluation.get("assessment", "partial").lower()
-                
-                if reasoning_status == "correct":
-                    break
-                
-                # Step 2: Regenerate SQL with feedback (with validation retries)
-                evaluation_note = note + f"\n\nThe previously generated SQL: `{sql_query}` was assessed as '{evaluation.get('assessment')}' because: {evaluation.get('reasoning', '*could not determine cause*')}. Please provide a corrected SQL query that better answers the question: '{question}'.\n\nCRITICAL: Return ONLY the SQL query without any explanation or comments."
-                
-                # Increase graph depth for 2nd+ reasoning attempts, up to max of 3
-                context_graph_depth = min(3, int(graph_depth) + step) if graph_depth < 3 and step > 0 else graph_depth
-                
-                # Regenerate SQL with validation retries
-                # Always validate during reasoning to ensure quality, regardless of global should_validate_sql flag
-                validation_iteration = 0
-                regen_is_valid = False
-                regen_error = ''
-                regen_sql = None
-                
-                while validation_iteration < retries and (regen_sql is None or not regen_is_valid):
-                    validation_iteration += 1
-                    validation_err_txt = f"\nThe regenerated SQL (`{regen_sql}`) was invalid with error: {regen_error}. Please generate a corrected query." if regen_error and "snowflake" not in llm._llm_type else ""
-                    
-                    regen_result = _generate_sql_with_llm(
-                        question=question,
-                        llm=llm,
-                        conn_params=conn_params,
-                        generate_sql_prompt=generate_sql_prompt,
-                        current_context=_build_sql_generation_context(
-                            conn_params=conn_params,
-                            schema=schema,
-                            concept=concept,
-                            concept_metadata=concept_metadata,
-                            graph_depth=context_graph_depth,
-                            include_tags=include_tags,
-                            exclude_properties=exclude_properties,
-                            db_is_case_sensitive=db_is_case_sensitive,
-                            max_limit=max_limit),
-                        note=evaluation_note + validation_err_txt,
-                        should_validate_sql=True,  # Always validate during reasoning
-                        timeout=timeout,
-                        debug=debug,
-                    )
-                    
-                    regen_sql = regen_result['sql']
-                    regen_is_valid = regen_result['is_valid']
-                    regen_error = regen_result['error']
-                    
-                    # Track token usage for each validation iteration
-                    if validation_iteration == 1:
-                        usage_metadata[f'generate_sql_reasoning_step_{step + 1}'] = {
-                            "approximate": regen_result['apx_token_count'],
-                            **regen_result['usage_metadata'],
-                        }
-                        if debug and 'p_hash' in regen_result:
-                            usage_metadata[f'generate_sql_reasoning_step_{step + 1}']['p_hash'] = regen_result['p_hash']
-                    else:
-                        usage_metadata[f'generate_sql_reasoning_step_{step + 1}_validation_{validation_iteration}'] = {
-                            "approximate": regen_result['apx_token_count'],
-                            **regen_result['usage_metadata'],
-                        }
-                        if debug and 'p_hash' in regen_result:
-                            usage_metadata[f'generate_sql_reasoning_step_{step + 1}_validation_{validation_iteration}']['p_hash'] = regen_result['p_hash']
-                
-                sql_query = regen_sql
-                is_sql_valid = regen_is_valid
-                error = regen_error
-                
-            except TimeoutError as e:
-                raise Exception(f"LLM call timed out: {str(e)}")
-            except Exception as e:
-                print(f"Warning: LLM reasoning failed: {e}")
-                break
+    except TimeoutError as e:
+        error = f"LLM call timed out: {str(e)}"
+        raise Exception(error)
+    except Exception as e:
+        error = f"LLM call failed: {str(e)}"
+        raise Exception(error)
     
     return {
         "sql": sql_query,
@@ -837,6 +1002,8 @@ def generate_sql(
         "schema": schema,
         "error": error if not is_sql_valid else None,
         "is_sql_valid": is_sql_valid if should_validate_sql else None,
+        "identify_concept_reason": identify_concept_reason,
+        "generate_sql_reason": generate_sql_reason,
         "reasoning_status": reasoning_status,
         "usage_metadata": usage_metadata,
     }

langchain_timbr/utils/timbr_utils.py

@@ -154,6 +154,33 @@ def get_datasources(conn_params: dict, filter_active: Optional[bool] = False) ->
     return res
 
 
+def get_timbr_agent_options(agent_name: str, conn_params: dict) -> dict:
+    """
+    Get all options for a specific agent from timbr sys_agents_options table.
+    
+    Args:
+        agent_name: Name of the agent to get options for
+        conn_params: Connection parameters for Timbr system engine
+        
+    Returns:
+        Dictionary of option_name -> option_value pairs
+    """
+    options = {}
+    
+    # Query agent options (case-insensitive match on agent_name)
+    options_query = f"SELECT option_name, option_value FROM timbr.sys_agents_options WHERE LOWER(agent_name) = LOWER('{agent_name}')"
+    
+    results = run_query(options_query, conn_params)
+    if len(results) == 0:
+        raise Exception(f'Agent "{agent_name}" not found or has no options defined.')
+    for row in results:
+        option_name = row.get('option_name')
+        option_value = row.get('option_value', '')
+        options[option_name] = option_value
+
+    return options
+
+
 def _validate(sql: str, conn_params: dict) -> bool:
     explain_sql = f"EXPLAIN {sql}"
     explain_res = run_query(explain_sql, conn_params)

{langchain_timbr-2.1.14.dist-info → langchain_timbr-3.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-timbr
-Version: 2.1.14
+Version: 3.0.0
 Summary: LangChain & LangGraph extensions that parse LLM prompts into Timbr semantic SQL and execute them.
 Project-URL: Homepage, https://github.com/WPSemantix/langchain-timbr
 Project-URL: Documentation, https://docs.timbr.ai/doc/docs/integration/langchain-sdk/

langchain_timbr-3.0.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+langchain_timbr/__init__.py,sha256=qNyk3Rt-8oWr_OGuU_E-6siNZXuCnvVEkj65EIuVbbQ,824
+langchain_timbr/_version.py,sha256=9fL11DDeXfhKmxyz_HrYU3Yy7BjMWrJklCddPlmAj6A,704
+langchain_timbr/config.py,sha256=Y0fTwkhLj8M-vORdVCAFykrSFIifDovV6BETfdIKZ9A,1973
+langchain_timbr/timbr_llm_connector.py,sha256=Y3nzWoocI5txvPGPAxwFsJde9k9l2J9ioB54MYRLrEQ,13288
+langchain_timbr/langchain/__init__.py,sha256=ejcsZKP9PK0j4WrrCCcvBXpDpP-TeRiVb21OIUJqix8,580
+langchain_timbr/langchain/execute_timbr_query_chain.py,sha256=UIUQR8adnWmGCrx6t1nnMrD8yoejgUMr80bf3bl2xUw,20251
+langchain_timbr/langchain/generate_answer_chain.py,sha256=fGq4Ls6cuHBzTCntl1kLHuCp43vEssDkWZA_gPTcm4E,5415
+langchain_timbr/langchain/generate_timbr_sql_chain.py,sha256=mb8VHTpq-Cw2UqDPDE-Z7dmJ7xtInktkN5nr6N9206g,13150
+langchain_timbr/langchain/identify_concept_chain.py,sha256=ga91QnuaXXxVAbx5Cz32jcq-PXby4zZacil2Kr-GTqo,8699
+langchain_timbr/langchain/timbr_sql_agent.py,sha256=Uxvw742o6478LvIIQUVK64tBYzDWObj6DBwWGMi0bi8,21895
+langchain_timbr/langchain/validate_timbr_sql_chain.py,sha256=Z1FfykDDba1lPSTN0J0Y2Fhxe2sOFqV9Y8-rudsTeJQ,13650
+langchain_timbr/langgraph/__init__.py,sha256=mKBFd0x01jWpRujUWe-suX3FFhenPoDxrvzs8I0mum0,457
+langchain_timbr/langgraph/execute_timbr_query_node.py,sha256=1JB8pMkSeBGxDMd64OXjZUUjvizILJN8bkz6ibbpgE8,6229
+langchain_timbr/langgraph/generate_response_node.py,sha256=V1XvbmkRBiJ_cExGpWXsBEUxvlLQA3hsVlsg6NHbD94,2504
+langchain_timbr/langgraph/generate_timbr_sql_node.py,sha256=BKFbvf9_YJmpfmCYPTpDm7z6Lvy0regmYGmNznPMl_0,5563
+langchain_timbr/langgraph/identify_concept_node.py,sha256=APhgyNW9YiG1d7lxiZWyFxABHo6vy8sQaXCDRnSPL8w,3821
+langchain_timbr/langgraph/validate_timbr_query_node.py,sha256=eFAIryr-oVrgbbtVHNQTR6md2XS_3cmC8pLgYQ89BiE,5401
+langchain_timbr/llm_wrapper/llm_wrapper.py,sha256=j94DqIGECXyfAVayLC7VaNxs_8n1qYFiHY2Qvt2B3Bc,17537
+langchain_timbr/llm_wrapper/timbr_llm_wrapper.py,sha256=sDqDOz0qu8b4WWlagjNceswMVyvEJ8yBWZq2etBh-T0,1362
+langchain_timbr/utils/general.py,sha256=KkehHvIj8GoQ_0KVXLcUVeaYaTtkuzgXmYYx2TXJhI4,10253
+langchain_timbr/utils/prompt_service.py,sha256=QVmfA9cHO2IPVsKG8V5cuMm2gPfvRq2VzLcx04sqT88,12197
+langchain_timbr/utils/temperature_supported_models.json,sha256=d3UmBUpG38zDjjB42IoGpHTUaf0pHMBRSPY99ao1a3g,1832
+langchain_timbr/utils/timbr_llm_utils.py,sha256=iuCPwEOmd0b5N8LNO3IV7K3qozlalUXvh_0QD8bHH28,41001
+langchain_timbr/utils/timbr_utils.py,sha256=olSwn_BYalkhiHR87zfgjosxxGwtMmsrQTqAtu64kPs,20603
+langchain_timbr-3.0.0.dist-info/METADATA,sha256=vvI-waiUk2ZNRxM791b5zpIIvap8xnCFcwjONW8kZkE,10767
+langchain_timbr-3.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+langchain_timbr-3.0.0.dist-info/licenses/LICENSE,sha256=0ITGFk2alkC7-e--bRGtuzDrv62USIiVyV2Crf3_L_0,1065
+langchain_timbr-3.0.0.dist-info/RECORD,,