create a UI interface etc to make it more accessible for non-tech users. (Mimic the work of ByteDance Coze)

[Osgood001]

• try coze
• try wenxinyiyan #3
• Write a programming guide in coze workflow (Take advantange of variable flow (as a general strucutre) and process it like it were a json) and complete the requirements on loop functionality #5

[Osgood001]

coze doc provided some use cases using the following building block:

INPUT

LLM
Knowledge
Code

OUTPUT

And control flow: select, loop

For example, we can create a simple function:

def search_for_news(user_input: string):
  return output(news_plugin(input(user_input)))

here, input() and output() are both configured by LLM, who’s functionality is predefined in the Agent prompt.

A more complex one use a LLM to tell the user’s intention and use a selector to switch between branches:

def user_intention(user_input: string):
  intend = LLM_1(user_input)
  if selector_1(intend):
    return output(weather_plugin(LLM_2(user_input))
  else:
    if selector_2(intend):
    return output(news_plugin(LLM_3(user_input))
    else:
      return output(user_input)

the loop condition is not explicitly written, we’ll use the generic python type.

[Osgood001]

Now we have the following demands:

1. Given a bunch of articles (Upload to Knowledge)
2. Extract Contents from Knowledge(Keys should be written explicitly in prompt)
3. For all the keys, for all the files, do this extraction
4. Combine and organize these things (With LLM or Code)
5. Output to a markdown file

[Osgood001]

Pseudo code:

def extractor(user_input: string):
  keys = LLM_keyExtractor(input(user_input))
  res = “”
  empty = 0
  while selector_not(empty):
    key, keys, empty = LLM_Pop(keys)
    res = LLM_Append(res, Knowledge(key))

  return createMarkdown_plugin((LLM_Markdown(res))

There’s no mature for loops to contain any of the built in block (i.e. it’s a static flow)
We can use a selector to guide the loop.

[Osgood001]

To make sure we have retrieved all the files, we need the title message first and do not proceed before the user ensures, this will be helpful to avoid frustration, the user only need to:

1. upload the file.
2. Ensure the files to be processed.
3. Input the keys/intentions
4. receive the output.

def academic_extractor(Void):
  keys = Knowledge(commands, “the default keys”)
  filenames = Knowledge(papers, “list the title of each file”)
  output(LLM_Counter(“There are in total X files, they are: {{filenames}}, by default, we will extract the following information: {{keys}}, are you ready to proceed? If not, provide adjustments to the file names and the keys“))
  if selector_Proceed(LLM_Proceed(user_input)):
    return extractor(filenames, keys)
  else:
    filenames, keys = LLM_Adjust(user_input, filenames, keys)
    go to LLM_Counter

def extractor(filenames, original_keys):
  res = “”
  if selector_NameNotEmpty(filenames):
    name, filenames = LLM_NamePop(filenames)
    keys = original_keys
    if selector_KeyNotEmpty(keys):
      key, keys = LLM_KeyPop(keys)
      res = LLM_Append(res, Knowledge(“find {{key}} in file {{name}}”))
      go to selector_KeyNotEmpty
    else:
      go to selector_KeyNotEmpty
  else:
    return res

[Osgood001]

Translated the above code to the diagram

It didn't work in places with loop, a more dedicated design is needed to solve the problem of variable sharing and loop condition.

Need to find a way to connect with the dev team in ByteDance : ( (I hate flow programming without loop condition)

[Osgood001]

Found a new way, will test it