Create a chain of chain

[veepdotai]

Requirement

I have 2 veeplets (AI pipelines):

• one to to create a case study (cs)
• one to create a linkedin post (li)

How can I mix them in a new pipeline called for example Case study + 5 LI that creates one case study and 5 LI posts based on the case study?

I don't want to reinvent the wheel of course and so I just want to reuse existing pipelines. I'd like to write something like that:

Create case Study with 5 LI: cs, li, li, li, li, li

[veepdotai]

Specifications

Let's imagine we have the 2 pipelines as you suggested:

• case study: cs, which is for example a 6 steps process (Plan, Introduction, P.1, P.2, P.3, Conclusion)
• linkedin post: li, which is a 1 step process (LI)

These 2 pipelines have been built with Veep builder.

Today, it would be possible to build a new veeplet (AI pipeline) that would contain @name_of_the_veeplet_to_use by simple describing it in the chain definition

Case study with 5 LI: cs, li, li, li, li, li

We could process such a veeplet in a different way than the one with prompts so a new and temporaray one would be created. This temp one would be decomposed in the following steps:

Plan, Introduction, P.1, P.2, P.3, Conclusion, LI, LI, LI, LI, LI

Presently, Veep would almost accept such a new pipeline but there are 2 problems:

• pipeline takes an input which is called {inspiration}. It's ok for the first step (Plan) but how could we do with the 5 LI steps that each wait for a {inspiration} that is in fact the result of the concatenation of all the previous parts (merge of Plan?, Introduction, P.1, P.2, P.3, Conclusion)
• steps names MUST be unique, which is not the case above. We could prefix the step name by a random string so it is always unique when executed
• steps may reference previous steps (in the same pipeline) using their names (which would be changed so they are unique).

This last point is not a problem because li veeplet is a one step process, but it would be in a pipeline with inter references).

[veepdotai]

Veeplets work like linux pipe. The previous temp pipeline could be viewed like this

• cs(Plan, Introduction, P.1, P.2, P.3, Conclusion) | LI | LI | LI | LI | LI

LI want to have the whole previous content, so we should have an OUTPUT step which would concatenate each step:

• OUTPUT = concatenate(Intro, P.1..., Conclusion)

We could imagine some things more clever because finally we are reinventing programming languages with import and scope statements and there surely exists an elegant solution but we just want a POC for the moment.

[veepdotai]

To give the ability to use any different input or output from previous generation outcomes, we could write the following:

• cs => output | li.1(cs.output) => output| li.2(cs.output) => output | li.3(cs.output) => output | li.4(cs.output) => output | li.5(cs.output) => output

To integrate an existing pipeline, use the following formalism:

• f(input: x) => output

where f is the name of the veeplet, x its input, and output its outcome. f must be unique at the end, when all elements are flatten. When this happens, the elements are prefixed by the surrounding element to avoid collision. When some elements are at the same level, like li above, they must be different. It may be li.1... li.3 but you could use li.first... li.next so you can reference them without ambiguity.

These elements may be referenced.

For example,

• cs(Plan, Introduction, P.1, P.2, P.3, Conclusion) | li.1(LI(cs.output)) | li.2(LI(cs.output)) | li.3(LI(cs.output)) | li.4(LI(cs.output)) | li.5(LI(cs.output))