npcsh 1.1.21__py3-none-any.whl → 1.1.23__py3-none-any.whl

npcsh/npc_team/jinxs/lib/core/convene.jinx

@@ -1,232 +0,0 @@
-jinx_name: convene
-description: Run a cycle of discussions between NPCs on a topic. The orchestrator convenes agents to discuss and synthesize.
-inputs:
-- topic: ""
-- npcs: "alicanto,corca,guac"
-- rounds: 3
-- model: null
-- provider: null
-steps:
-  - name: convene_discussion
-    engine: python
-    code: |
-      from termcolor import colored
-      from npcpy.llm_funcs import get_llm_response
-
-      topic = context.get('topic', '')
-      npcs_str = context.get('npcs', 'alicanto,corca,guac')
-      rounds = int(context.get('rounds', 3))
-
-      npc = context.get('npc')
-      team = context.get('team')
-      messages = context.get('messages', [])
-
-      model = context.get('model') or (npc.model if npc else (state.chat_model if state else 'llama3.2'))
-      provider = context.get('provider') or (npc.provider if npc else (state.chat_provider if state else 'ollama'))
-
-      if not topic:
-          context['output'] = """Usage: /convene <topic>
-
-      Options:
-        --npcs LIST      Comma-separated NPC names (default: alicanto,corca,guac)
-        --rounds N       Number of discussion rounds (default: 3)
-
-      Example: /convene "How should we approach the database migration?" --npcs corca,guac,frederic
-      """
-          exit()
-
-      npc_names = [n.strip() for n in npcs_str.split(',')]
-
-      print(f"""
-       ██████  ██████  ███    ██ ██    ██ ███████ ███    ██ ███████
-      ██      ██    ██ ████   ██ ██    ██ ██      ████   ██ ██
-      ██      ██    ██ ██ ██  ██ ██    ██ █████   ██ ██  ██ █████
-      ██      ██    ██ ██  ██ ██  ██  ██  ██      ██  ██ ██ ██
-       ██████  ██████  ██   ████   ████   ███████ ██   ████ ███████
-
-      Convening Discussion
-      Topic: {topic}
-      Participants: {', '.join(npc_names)}
-      Rounds: {rounds}
-      """)
-
-      # Get NPC personas
-      participants = []
-      for name in npc_names:
-          if team and hasattr(team, 'npcs') and name in team.npcs:
-              target_npc = team.npcs[name]
-              persona = getattr(target_npc, 'primary_directive', f'{name} specialist')
-              participants.append({'name': name, 'persona': persona, 'npc': target_npc})
-          else:
-              participants.append({'name': name, 'persona': f'{name} - general assistant', 'npc': None})
-
-      import random
-
-      discussion_log = []
-
-      for round_num in range(1, rounds + 1):
-          print(colored(f"\n{'='*60}", "cyan"))
-          print(colored(f"  ROUND {round_num}/{rounds}", "cyan", attrs=["bold"]))
-          print(colored(f"{'='*60}", "cyan"))
-
-          round_contributions = []
-
-          for participant in participants:
-              name = participant['name']
-              persona = participant['persona']
-
-              # Build context from previous contributions
-              prev_context = ""
-              if discussion_log:
-                  prev_context = "\n\nPrevious discussion:\n"
-                  for entry in discussion_log[-len(participants)*2:]:
-                      prev_context += f"[{entry['speaker']}]: {entry['contribution'][:200]}...\n"
-
-              if round_contributions:
-                  prev_context += "\nThis round so far:\n"
-                  for entry in round_contributions:
-                      prev_context += f"[{entry['speaker']}]: {entry['contribution'][:200]}...\n"
-
-              prompt = f"""You are {name}. {persona}
-
-      Topic under discussion: "{topic}"
-      {prev_context}
-
-      Provide your perspective on this topic. Be concise but insightful.
-      Build on what others have said if applicable.
-      If you disagree with something, explain why constructively.
-      """
-
-              print(colored(f"\n[{name}]:", "yellow", attrs=["bold"]))
-
-              resp = get_llm_response(
-                  prompt,
-                  model=model,
-                  provider=provider,
-                  npc=participant.get('npc') or npc,
-                  temperature=0.7
-              )
-
-              contribution = str(resp.get('response', ''))
-              print(contribution)
-
-              entry = {
-                  'round': round_num,
-                  'speaker': name,
-                  'contribution': contribution
-              }
-              round_contributions.append(entry)
-              discussion_log.append(entry)
-
-              # Sample a followup from another participant
-              other_participants = [p for p in participants if p['name'] != name]
-              if other_participants:
-                  followup_participant = random.choice(other_participants)
-                  followup_name = followup_participant['name']
-                  followup_persona = followup_participant['persona']
-
-                  followup_prompt = f"""You are {followup_name}. {followup_persona}
-
-      Topic: "{topic}"
-
-      {name} just said: "{contribution[:500]}"
-
-      Respond briefly to this specific point - agree, disagree, build on it, or ask a clarifying question.
-      Keep it to 2-3 sentences.
-      """
-
-                  print(colored(f"\n  [{followup_name} responds]:", "cyan"))
-
-                  followup_resp = get_llm_response(
-                      followup_prompt,
-                      model=model,
-                      provider=provider,
-                      npc=followup_participant.get('npc') or npc,
-                      temperature=0.7
-                  )
-
-                  followup_contribution = str(followup_resp.get('response', ''))
-                  print(f"  {followup_contribution}")
-
-                  discussion_log.append({
-                      'round': round_num,
-                      'speaker': followup_name,
-                      'contribution': followup_contribution,
-                      'type': 'followup'
-                  })
-
-                  # Probability of original speaker responding back vs someone else
-                  if random.random() < 0.4:
-                      # Original speaker responds
-                      responder = participant
-                      responder_name = name
-                  else:
-                      # Sample from others (could be followup person or someone else)
-                      responder = random.choice(other_participants)
-                      responder_name = responder['name']
-
-                  if random.random() < 0.6:  # 60% chance of a counter-response
-                      counter_prompt = f"""You are {responder_name}. {responder['persona']}
-
-      Topic: "{topic}"
-
-      {followup_name} responded: "{followup_contribution}"
-
-      Brief reaction (1-2 sentences). Move the discussion forward.
-      """
-
-                      print(colored(f"\n  [{responder_name}]:", "magenta"))
-
-                      counter_resp = get_llm_response(
-                          counter_prompt,
-                          model=model,
-                          provider=provider,
-                          npc=responder.get('npc') or npc,
-                          temperature=0.7
-                      )
-
-                      counter_contribution = str(counter_resp.get('response', ''))
-                      print(f"  {counter_contribution}")
-
-                      discussion_log.append({
-                          'round': round_num,
-                          'speaker': responder_name,
-                          'contribution': counter_contribution,
-                          'type': 'counter'
-                      })
-
-      # Synthesis
-      print(colored(f"\n{'='*60}", "green"))
-      print(colored("  SYNTHESIS", "green", attrs=["bold"]))
-      print(colored(f"{'='*60}", "green"))
-
-      all_contributions = "\n".join([
-          f"[{e['speaker']} - Round {e['round']}]: {e['contribution']}"
-          for e in discussion_log
-      ])
-
-      synthesis_prompt = f"""As the convener of this discussion on "{topic}", synthesize the key points:
-
-      Full discussion:
-      {all_contributions}
-
-      Provide:
-      1. Key agreements and consensus points
-      2. Areas of disagreement or tension
-      3. Novel ideas that emerged
-      4. Recommended next steps or actions
-      """
-
-      resp = get_llm_response(synthesis_prompt, model=model, provider=provider, npc=npc, temperature=0.4)
-      synthesis = str(resp.get('response', ''))
-      print(synthesis)
-
-      context['output'] = synthesis
-      context['messages'] = messages
-      context['convene_result'] = {
-          'topic': topic,
-          'participants': npc_names,
-          'rounds': rounds,
-          'discussion': discussion_log,
-          'synthesis': synthesis
-      }

npcsh/npc_team/jinxs/lib/core/search/kg_search.jinx

@@ -1,429 +0,0 @@
-jinx_name: kg_search
-description: Search the knowledge graph with interactive TUI
-interactive: true
-inputs:
-- query: ""
-- type: "facts"
-- mode: "keyword"
-- concept: ""
-- depth: "2"
-- breadth: "5"
-- max_results: "20"
-- threshold: "0.6"
-- npc_name: ""
-- team_name: ""
-- db_path: ""
-- text: "false"
-
-steps:
-  - name: search_kg
-    engine: python
-    code: |
-      import os
-      import sys
-      import tty
-      import termios
-      from npcpy.memory.command_history import CommandHistory
-      from npcpy.memory.knowledge_graph import (
-          kg_search_facts, kg_list_concepts, kg_get_facts_for_concept,
-          kg_get_all_facts, kg_link_search, kg_embedding_search,
-          kg_hybrid_search, kg_explore_concept
-      )
-
-      query = context.get('query', '').strip()
-      search_type = context.get('type', 'facts').lower()
-      search_mode = context.get('mode', 'keyword').lower()
-      concept = context.get('concept', '').strip()
-      max_depth = int(context.get('depth') or 2)
-      breadth = int(context.get('breadth') or 5)
-      max_results = int(context.get('max_results') or 20)
-      threshold = float(context.get('threshold') or 0.6)
-      text_mode = context.get('text', '').lower() in ('true', '1', 'yes')
-
-      if not query and search_type == 'facts' and not concept:
-          lines = [
-              "Usage: /kg_search <query> [mode=keyword|embedding|link|hybrid|all]",
-              "",
-              "Search Modes:",
-              "  keyword   - Simple keyword matching (default, fast)",
-              "  embedding - Semantic similarity using embeddings",
-              "  link      - Traverse graph links from keyword matches",
-              "  hybrid    - Combine keyword + link traversal",
-              "  all       - Combine all methods (slowest, most thorough)",
-              "",
-              "Options:",
-              "  type        - Result type: facts, concepts, all",
-              "  concept     - Explore a specific concept",
-              "  depth       - Link traversal depth (default: 2)",
-              "  breadth     - Results per traversal hop (default: 5)",
-              "  max_results - Max total results (default: 20)",
-              "  threshold   - Embedding similarity threshold (default: 0.6)",
-              "  text        - Text-only output, no TUI (true/false)",
-              "",
-              "TUI Controls:",
-              "  j/k or arrows - Navigate",
-              "  1/2/3         - Sort by score/concept/type",
-              "  c             - Toggle concepts view",
-              "  e             - Explore selected concept",
-              "  p             - Preview full fact/concept",
-              "  q/ESC         - Quit",
-              "",
-              "Examples:",
-              "  /kg_search python",
-              "  /kg_search python mode=embedding",
-              "  /kg_search python mode=link depth=3",
-              "  /kg_search type=concepts",
-              "  /kg_search concept=coding",
-          ]
-          context['output'] = "\n".join(lines)
-      else:
-          db_path = context.get('db_path') or os.path.expanduser("~/npcsh_history.db")
-
-          try:
-              cmd_history = CommandHistory(db_path)
-              engine = cmd_history.engine
-
-              team_obj = None
-              try:
-                  team_obj = state.team if 'state' in dir() and state else None
-              except:
-                  pass
-              npc_obj = npc if 'npc' in dir() else None
-
-              emodel = None
-              eprovider = None
-              try:
-                  if 'state' in dir() and state:
-                      emodel = getattr(state, 'embedding_model', None)
-                      eprovider = getattr(state, 'embedding_provider', None)
-              except:
-                  pass
-
-              # Collect results
-              results = []
-
-              if concept:
-                  result = kg_explore_concept(engine, concept, max_depth=max_depth, breadth_per_step=breadth)
-                  for i, f in enumerate(result.get('direct_facts', [])):
-                      results.append({'type': 'fact', 'content': str(f), 'score': 1.0, 'concept': concept, 'source': 'direct'})
-                  for i, f in enumerate(result.get('extended_facts', [])):
-                      results.append({'type': 'fact', 'content': str(f), 'score': 0.5, 'concept': concept, 'source': 'extended'})
-                  for c in result.get('related_concepts', []):
-                      results.append({'type': 'concept', 'content': str(c), 'score': 0.8, 'concept': concept, 'source': 'related'})
-
-              elif search_type == 'concepts':
-                  concepts = kg_list_concepts(engine, search_all_scopes=True)
-                  for c in concepts:
-                      results.append({'type': 'concept', 'content': str(c), 'score': 1.0, 'concept': str(c), 'source': 'list'})
-
-              elif search_type == 'all' and not query:
-                  facts = kg_get_all_facts(engine, search_all_scopes=True)
-                  for f in facts[:max_results]:
-                      results.append({'type': 'fact', 'content': str(f), 'score': 1.0, 'concept': '', 'source': 'all'})
-
-              elif search_mode == 'embedding':
-                  raw_results = kg_embedding_search(
-                      engine, query,
-                      embedding_model=emodel, embedding_provider=eprovider,
-                      similarity_threshold=threshold, max_results=max_results,
-                      search_all_scopes=True
-                  )
-                  for r in raw_results:
-                      results.append({
-                          'type': r.get('type', 'fact'),
-                          'content': str(r.get('content', '')),
-                          'score': r.get('score', 0),
-                          'concept': r.get('concept', ''),
-                          'source': 'embedding'
-                      })
-
-              elif search_mode == 'link':
-                  raw_results = kg_link_search(
-                      engine, query,
-                      max_depth=max_depth, breadth_per_step=breadth, max_results=max_results,
-                      search_all_scopes=True
-                  )
-                  for r in raw_results:
-                      results.append({
-                          'type': r.get('type', 'fact'),
-                          'content': str(r.get('content', '')),
-                          'score': r.get('score', 0),
-                          'concept': r.get('concept', ''),
-                          'source': f"link-d{r.get('depth', 0)}"
-                      })
-
-              elif search_mode in ['hybrid', 'all', 'keyword+link', 'keyword+embedding']:
-                  raw_results = kg_hybrid_search(
-                      engine, query,
-                      mode=search_mode if search_mode != 'hybrid' else 'keyword+link',
-                      max_depth=max_depth, breadth_per_step=breadth, max_results=max_results,
-                      embedding_model=emodel, embedding_provider=eprovider,
-                      similarity_threshold=threshold,
-                      search_all_scopes=True
-                  )
-                  for r in raw_results:
-                      results.append({
-                          'type': r.get('type', 'fact'),
-                          'content': str(r.get('content', '')),
-                          'score': r.get('score', 0),
-                          'concept': r.get('concept', ''),
-                          'source': r.get('source', 'hybrid')
-                      })
-
-              else:
-                  # Default keyword search
-                  facts = kg_search_facts(engine, query, search_all_scopes=True)
-                  for f in facts[:max_results]:
-                      results.append({'type': 'fact', 'content': str(f), 'score': 1.0, 'concept': '', 'source': 'keyword'})
-
-              if not results:
-                  context['output'] = f"No KG results found for '{query}'"
-              elif text_mode:
-                  # Text-only output
-                  lines = [f"Found {len(results)} KG results:", ""]
-                  for i, r in enumerate(results, 1):
-                      score = f"{r['score']:.2f}" if isinstance(r['score'], float) else str(r['score'])
-                      lines.append(f"{i}. [{r['type']} {score}] {r['content'][:80]}")
-                  context['output'] = "\n".join(lines)
-              else:
-                  # Interactive TUI mode
-                  def get_terminal_size():
-                      try:
-                          size = os.get_terminal_size()
-                          return size.columns, size.lines
-                      except:
-                          return 80, 24
-
-                  width, height = get_terminal_size()
-                  selected = 0
-                  scroll = 0
-                  list_height = height - 5
-                  mode = 'list'
-                  preview_scroll = 0
-                  sort_mode = 'score'  # score, concept, type
-                  type_filter = 'all'  # all, fact, concept
-
-                  def sort_results(results, sort_mode):
-                      if sort_mode == 'score':
-                          return sorted(results, key=lambda x: x.get('score', 0), reverse=True)
-                      elif sort_mode == 'concept':
-                          return sorted(results, key=lambda x: (x.get('concept', ''), -x.get('score', 0)))
-                      elif sort_mode == 'type':
-                          return sorted(results, key=lambda x: (x.get('type', ''), -x.get('score', 0)))
-                      return results
-
-                  def filter_results(results, type_filter):
-                      if type_filter == 'all':
-                          return results
-                      return [r for r in results if r.get('type') == type_filter]
-
-                  display_results = filter_results(sort_results(results, sort_mode), type_filter)
-
-                  fd = sys.stdin.fileno()
-                  old_settings = termios.tcgetattr(fd)
-
-                  try:
-                      tty.setcbreak(fd)
-                      sys.stdout.write('\033[?25l')
-                      sys.stdout.write('\033[2J\033[H')
-
-                      while True:
-                          width, height = get_terminal_size()
-                          list_height = height - 5
-
-                          if mode == 'list':
-                              if selected < scroll:
-                                  scroll = selected
-                              elif selected >= scroll + list_height:
-                                  scroll = selected - list_height + 1
-
-                          sys.stdout.write('\033[H')
-
-                          # Header
-                          if mode == 'list':
-                              sort_ind = {'score': '1', 'concept': '2', 'type': '3'}[sort_mode]
-                              label = query or concept or search_type
-                              header = f" KG SEARCH ({len(display_results)} results): '{label}' [sort:{sort_mode}({sort_ind}) filter:{type_filter}] "
-                          else:
-                              header = f" PREVIEW: {display_results[selected]['type']} "
-                          sys.stdout.write(f'\033[7;1m{header.ljust(width)}\033[0m\n')
-
-                          # Column headers
-                          if mode == 'list':
-                              col_header = f' {"TYPE":<8} {"SCORE":<6} {"CONCEPT":<15} {"CONTENT":<50}'
-                              sys.stdout.write(f'\033[90m{col_header[:width]}\033[0m\n')
-                          else:
-                              sys.stdout.write(f'\033[90m{"─" * width}\033[0m\n')
-
-                          if mode == 'list':
-                              for i in range(list_height):
-                                  idx = scroll + i
-                                  sys.stdout.write(f'\033[{3+i};1H\033[K')
-                                  if idx >= len(display_results):
-                                      continue
-
-                                  r = display_results[idx]
-                                  rtype = r.get('type', '?')[:8]
-                                  score = f"{r.get('score', 0):.2f}" if isinstance(r.get('score'), float) else str(r.get('score', ''))[:6]
-                                  concept_str = (r.get('concept', '') or '')[:15]
-                                  content = (r.get('content', '') or '')[:60].replace('\n', ' ')
-
-                                  # Color by type
-                                  if r.get('type') == 'concept':
-                                      type_color = '\033[35m'  # magenta
-                                  else:
-                                      type_color = '\033[36m'  # cyan
-
-                                  line = f" {type_color}{rtype:<8}\033[0m {score:<6} {concept_str:<15} {content}"
-                                  line = line[:width+15]
-
-                                  if idx == selected:
-                                      sys.stdout.write(f'\033[7;1m>{line}\033[0m')
-                                  else:
-                                      sys.stdout.write(f' {line}')
-
-                              # Status bar
-                              sys.stdout.write(f'\033[{height-2};1H\033[K\033[90m{"─" * width}\033[0m')
-                              sel = display_results[selected] if display_results else {}
-                              source = sel.get('source', '')
-                              sys.stdout.write(f'\033[{height-1};1H\033[K Source: {source}'.ljust(width))
-                              sys.stdout.write(f'\033[{height};1H\033[K\033[7m j/k:Nav 1/2/3:Sort c:Concepts e:Explore p:Preview q:Quit [{selected+1}/{len(display_results)}] \033[0m')
-
-                          else:  # preview mode
-                              sel = display_results[selected]
-                              content = sel.get('content', '')
-                              lines = content.split('\n')
-
-                              # Add metadata at top
-                              meta_lines = [
-                                  f"Type: {sel.get('type', '')}",
-                                  f"Score: {sel.get('score', '')}",
-                                  f"Concept: {sel.get('concept', '')}",
-                                  f"Source: {sel.get('source', '')}",
-                                  "─" * 40,
-                              ]
-                              all_lines = meta_lines + lines
-
-                              for i in range(list_height):
-                                  idx = preview_scroll + i
-                                  sys.stdout.write(f'\033[{3+i};1H\033[K')
-                                  if idx < len(all_lines):
-                                      sys.stdout.write(all_lines[idx][:width-1])
-
-                              sys.stdout.write(f'\033[{height-2};1H\033[K\033[90m{"─" * width}\033[0m')
-                              sys.stdout.write(f'\033[{height-1};1H\033[K [{preview_scroll+1}/{len(all_lines)} lines]')
-                              sys.stdout.write(f'\033[{height};1H\033[K\033[7m j/k:Scroll b:Back e:Explore q:Quit \033[0m')
-
-                          sys.stdout.flush()
-
-                          c = os.read(fd, 1).decode('latin-1')
-
-                          if c == '\x1b':
-                              import select as _sel
-                              if _sel.select([fd], [], [], 0.05)[0]:
-                                  c2 = os.read(fd, 1).decode('latin-1')
-                              else:
-                                  if mode == 'preview':
-                                      mode = 'list'
-                                      sys.stdout.write('\033[2J\033[H')
-                                  else:
-                                      context['output'] = "Cancelled."
-                                      break
-                                  continue
-                              if c2 == '[':
-                                  c3 = os.read(fd, 1).decode('latin-1')
-                                  if c3 == 'A':  # Up
-                                      if mode == 'list' and selected > 0:
-                                          selected -= 1
-                                      elif mode == 'preview' and preview_scroll > 0:
-                                          preview_scroll -= 1
-                                  elif c3 == 'B':  # Down
-                                      if mode == 'list' and selected < len(display_results) - 1:
-                                          selected += 1
-                                      elif mode == 'preview':
-                                          sel = display_results[selected]
-                                          content = sel.get('content', '')
-                                          all_lines = content.split('\n')
-                                          if preview_scroll < max(0, len(all_lines) + 5 - list_height):
-                                              preview_scroll += 1
-                              else:
-                                  if mode == 'preview':
-                                      mode = 'list'
-                                      sys.stdout.write('\033[2J\033[H')
-                                  else:
-                                      context['output'] = "Cancelled."
-                                      break
-                              continue
-
-                          if c == 'q' or c == '\x03':
-                              context['output'] = "Cancelled."
-                              break
-                          elif c == 'k':
-                              if mode == 'list' and selected > 0:
-                                  selected -= 1
-                              elif mode == 'preview' and preview_scroll > 0:
-                                  preview_scroll -= 1
-                          elif c == 'j':
-                              if mode == 'list' and selected < len(display_results) - 1:
-                                  selected += 1
-                              elif mode == 'preview':
-                                  sel = display_results[selected]
-                                  content = sel.get('content', '')
-                                  all_lines = content.split('\n')
-                                  if preview_scroll < max(0, len(all_lines) + 5 - list_height):
-                                      preview_scroll += 1
-                          elif c == '1':
-                              sort_mode = 'score'
-                              display_results = filter_results(sort_results(results, sort_mode), type_filter)
-                              selected = 0
-                              scroll = 0
-                          elif c == '2':
-                              sort_mode = 'concept'
-                              display_results = filter_results(sort_results(results, sort_mode), type_filter)
-                              selected = 0
-                              scroll = 0
-                          elif c == '3':
-                              sort_mode = 'type'
-                              display_results = filter_results(sort_results(results, sort_mode), type_filter)
-                              selected = 0
-                              scroll = 0
-                          elif c == 'c' and mode == 'list':
-                              # Toggle type filter
-                              if type_filter == 'all':
-                                  type_filter = 'concept'
-                              elif type_filter == 'concept':
-                                  type_filter = 'fact'
-                              else:
-                                  type_filter = 'all'
-                              display_results = filter_results(sort_results(results, sort_mode), type_filter)
-                              selected = 0
-                              scroll = 0
-                          elif c == 'e' and display_results:
-                              # Explore the selected concept
-                              sel = display_results[selected]
-                              explore_concept = sel.get('concept') or sel.get('content', '')
-                              if sel.get('type') == 'concept':
-                                  explore_concept = sel.get('content', '')
-                              context['output'] = f"Explore concept: {explore_concept}\n\nRun: /kg_search concept={explore_concept}"
-                              break
-                          elif c == 'p' and mode == 'list' and display_results:
-                              mode = 'preview'
-                              preview_scroll = 0
-                              sys.stdout.write('\033[2J\033[H')
-                          elif c == 'b' and mode == 'preview':
-                              mode = 'list'
-                              sys.stdout.write('\033[2J\033[H')
-                          elif c in ('\r', '\n') and display_results:
-                              sel = display_results[selected]
-                              context['output'] = f"Selected: {sel.get('content', '')[:100]}"
-                              break
-
-                  finally:
-                      termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
-                      sys.stdout.write('\033[?25h')
-                      sys.stdout.write('\033[2J\033[H')
-                      sys.stdout.flush()
-
-          except Exception as e:
-              import traceback
-              context['output'] = "KG search error: " + str(e) + "\n" + traceback.format_exc()